From 9a8988bf805d29d92fdf09fe38aceec75af3d093 Mon Sep 17 00:00:00 2001
From: Ahmed Fwela <ahmednfwela@bdaya-dev.com>
Date: Fri, 5 Nov 2021 06:06:33 +0200
Subject: [PATCH 01/26] .

---
 MongoDB.Entities/DB/DB.cs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/MongoDB.Entities/DB/DB.cs b/MongoDB.Entities/DB/DB.cs
index a37b098b6..96f44d4a5 100644
--- a/MongoDB.Entities/DB/DB.cs
+++ b/MongoDB.Entities/DB/DB.cs
@@ -32,6 +32,8 @@ static DB()
                 _ => true);
         }
 
+        //TODO: refactor api
+
         //key: FullDBName(including tenant prefix - ex: TenantX~DBName)
         private static readonly ConcurrentDictionary<string, IMongoDatabase> dbs = new();
         private static IMongoDatabase defaultDb;

From 218bb9e3a3a0ba842028dfa4d82eade041078175 Mon Sep 17 00:00:00 2001
From: Ahmed Fwela <ahmednfwela@bdaya-dev.com>
Date: Fri, 5 Nov 2021 06:59:32 +0200
Subject: [PATCH 02/26] Initial WIP

---
 MongoDB.Entities/DBContext/DBContext.cs       |   2 +-
 .../MongoContext/MongoContext.IMongoClient.cs | 163 ++++++++++++++++++
 MongoDB.Entities/MongoContext/MongoContext.cs |  52 ++++++
 3 files changed, 216 insertions(+), 1 deletion(-)
 create mode 100644 MongoDB.Entities/MongoContext/MongoContext.IMongoClient.cs
 create mode 100644 MongoDB.Entities/MongoContext/MongoContext.cs

diff --git a/MongoDB.Entities/DBContext/DBContext.cs b/MongoDB.Entities/DBContext/DBContext.cs
index 6339f0f93..35be4b99c 100644
--- a/MongoDB.Entities/DBContext/DBContext.cs
+++ b/MongoDB.Entities/DBContext/DBContext.cs
@@ -16,7 +16,7 @@ public partial class DBContext
         /// Returns the session object used for transactions
         /// </summary>
         public IClientSessionHandle Session { get; protected set; }
-
+        public MongoContext MongoContext { get; set; }
         /// <summary>
         /// The value of this property will be automatically set on entities when saving/updating if the entity has a ModifiedBy property
         /// </summary>
diff --git a/MongoDB.Entities/MongoContext/MongoContext.IMongoClient.cs b/MongoDB.Entities/MongoContext/MongoContext.IMongoClient.cs
new file mode 100644
index 000000000..ae7a4aa98
--- /dev/null
+++ b/MongoDB.Entities/MongoContext/MongoContext.IMongoClient.cs
@@ -0,0 +1,163 @@
+using MongoDB.Bson;
+using MongoDB.Driver;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace MongoDB.Entities
+{
+    public partial class MongoContext
+    {
+        public void DropDatabase(string name, CancellationToken cancellationToken = default)
+        {
+            Client.DropDatabase(name, cancellationToken);
+        }
+
+        public void DropDatabase(IClientSessionHandle session, string name, CancellationToken cancellationToken = default)
+        {
+            Client.DropDatabase(session, name, cancellationToken);
+        }
+
+        public Task DropDatabaseAsync(string name, CancellationToken cancellationToken = default)
+        {
+            return Client.DropDatabaseAsync(name, cancellationToken);
+        }
+
+        public Task DropDatabaseAsync(IClientSessionHandle session, string name, CancellationToken cancellationToken = default)
+        {
+            return Client.DropDatabaseAsync(session, name, cancellationToken);
+        }
+
+        public IMongoDatabase GetDatabase(string name, MongoDatabaseSettings settings = null)
+        {
+            return Client.GetDatabase(name, settings);
+        }
+
+        public IAsyncCursor<string> ListDatabaseNames(CancellationToken cancellationToken = default)
+        {
+            return Client.ListDatabaseNames(cancellationToken);
+        }
+
+        public IAsyncCursor<string> ListDatabaseNames(ListDatabaseNamesOptions options, CancellationToken cancellationToken = default)
+        {
+            return Client.ListDatabaseNames(options, cancellationToken);
+        }
+
+        public IAsyncCursor<string> ListDatabaseNames(IClientSessionHandle session, CancellationToken cancellationToken = default)
+        {
+            return Client.ListDatabaseNames(session, cancellationToken);
+        }
+
+        public IAsyncCursor<string> ListDatabaseNames(IClientSessionHandle session, ListDatabaseNamesOptions options, CancellationToken cancellationToken = default)
+        {
+            return Client.ListDatabaseNames(session, options, cancellationToken);
+        }
+
+        public Task<IAsyncCursor<string>> ListDatabaseNamesAsync(CancellationToken cancellationToken = default)
+        {
+            return Client.ListDatabaseNamesAsync(cancellationToken);
+        }
+
+        public Task<IAsyncCursor<string>> ListDatabaseNamesAsync(ListDatabaseNamesOptions options, CancellationToken cancellationToken = default)
+        {
+            return Client.ListDatabaseNamesAsync(options, cancellationToken);
+        }
+
+        public Task<IAsyncCursor<string>> ListDatabaseNamesAsync(IClientSessionHandle session, CancellationToken cancellationToken = default)
+        {
+            return Client.ListDatabaseNamesAsync(session, cancellationToken);
+        }
+
+        public Task<IAsyncCursor<string>> ListDatabaseNamesAsync(IClientSessionHandle session, ListDatabaseNamesOptions options, CancellationToken cancellationToken = default)
+        {
+            return Client.ListDatabaseNamesAsync(session, options, cancellationToken);
+        }
+
+        public IAsyncCursor<BsonDocument> ListDatabases(CancellationToken cancellationToken = default)
+        {
+            return Client.ListDatabases(cancellationToken);
+        }
+
+        public IAsyncCursor<BsonDocument> ListDatabases(ListDatabasesOptions options, CancellationToken cancellationToken = default)
+        {
+            return Client.ListDatabases(options, cancellationToken);
+        }
+
+        public IAsyncCursor<BsonDocument> ListDatabases(IClientSessionHandle session, CancellationToken cancellationToken = default)
+        {
+            return Client.ListDatabases(session, cancellationToken);
+        }
+
+        public IAsyncCursor<BsonDocument> ListDatabases(IClientSessionHandle session, ListDatabasesOptions options, CancellationToken cancellationToken = default)
+        {
+            return Client.ListDatabases(session, options, cancellationToken);
+        }
+
+        public Task<IAsyncCursor<BsonDocument>> ListDatabasesAsync(CancellationToken cancellationToken = default)
+        {
+            return Client.ListDatabasesAsync(cancellationToken);
+        }
+
+        public Task<IAsyncCursor<BsonDocument>> ListDatabasesAsync(ListDatabasesOptions options, CancellationToken cancellationToken = default)
+        {
+            return Client.ListDatabasesAsync(options, cancellationToken);
+        }
+
+        public Task<IAsyncCursor<BsonDocument>> ListDatabasesAsync(IClientSessionHandle session, CancellationToken cancellationToken = default)
+        {
+            return Client.ListDatabasesAsync(session, cancellationToken);
+        }
+
+        public Task<IAsyncCursor<BsonDocument>> ListDatabasesAsync(IClientSessionHandle session, ListDatabasesOptions options, CancellationToken cancellationToken = default)
+        {
+            return Client.ListDatabasesAsync(session, options, cancellationToken);
+        }
+
+        public IClientSessionHandle StartSession(ClientSessionOptions options = null, CancellationToken cancellationToken = default)
+        {
+            return Client.StartSession(options, cancellationToken);
+        }
+
+        public Task<IClientSessionHandle> StartSessionAsync(ClientSessionOptions options = null, CancellationToken cancellationToken = default)
+        {
+            return Client.StartSessionAsync(options, cancellationToken);
+        }
+
+        public IChangeStreamCursor<TResult> Watch<TResult>(PipelineDefinition<ChangeStreamDocument<BsonDocument>, TResult> pipeline, ChangeStreamOptions options = null, CancellationToken cancellationToken = default)
+        {
+            return Client.Watch(pipeline, options, cancellationToken);
+        }
+
+        public IChangeStreamCursor<TResult> Watch<TResult>(IClientSessionHandle session, PipelineDefinition<ChangeStreamDocument<BsonDocument>, TResult> pipeline, ChangeStreamOptions options = null, CancellationToken cancellationToken = default)
+        {
+            return Client.Watch(session, pipeline, options, cancellationToken);
+        }
+
+        public Task<IChangeStreamCursor<TResult>> WatchAsync<TResult>(PipelineDefinition<ChangeStreamDocument<BsonDocument>, TResult> pipeline, ChangeStreamOptions options = null, CancellationToken cancellationToken = default)
+        {
+            return Client.WatchAsync(pipeline, options, cancellationToken);
+        }
+
+        public Task<IChangeStreamCursor<TResult>> WatchAsync<TResult>(IClientSessionHandle session, PipelineDefinition<ChangeStreamDocument<BsonDocument>, TResult> pipeline, ChangeStreamOptions options = null, CancellationToken cancellationToken = default)
+        {
+            return Client.WatchAsync(session, pipeline, options, cancellationToken);
+        }
+
+        public IMongoClient WithReadConcern(ReadConcern readConcern)
+        {
+            return Client.WithReadConcern(readConcern);
+        }
+
+        public IMongoClient WithReadPreference(ReadPreference readPreference)
+        {
+            return Client.WithReadPreference(readPreference);
+        }
+
+        public IMongoClient WithWriteConcern(WriteConcern writeConcern)
+        {
+            return Client.WithWriteConcern(writeConcern);
+        }
+    }
+}
diff --git a/MongoDB.Entities/MongoContext/MongoContext.cs b/MongoDB.Entities/MongoContext/MongoContext.cs
new file mode 100644
index 000000000..64dd22d9e
--- /dev/null
+++ b/MongoDB.Entities/MongoContext/MongoContext.cs
@@ -0,0 +1,52 @@
+using MongoDB.Driver;
+using MongoDB.Driver.Core.Clusters;
+using System.Collections.Generic;
+
+namespace MongoDB.Entities
+{
+    /// <summary>
+    /// MongoContext is simply a wrapper around a <see cref="IMongoClient"/>
+    /// </summary>
+    public partial class MongoContext : IMongoClient
+    {
+        /// <summary>
+        /// Creates a new <see cref="MongoContext"/> from an existing <see cref="IMongoClient"/>
+        /// </summary>        
+        public MongoContext(IMongoClient client)
+        {
+            Client = client;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="MongoContext"/> and a new <see cref="MongoClient"/> from a <see cref="MongoClientSettings"/> object
+        /// </summary>      
+        public MongoContext(MongoClientSettings settings) : this(new MongoClient(settings))
+        {
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="MongoContext"/>, <see cref="MongoClient"/> and <see cref="MongoClientSettings"/> from a <see cref="MongoUrl"/> object
+        /// </summary>
+        public MongoContext(MongoUrl url) : this(MongoClientSettings.FromUrl(url))
+        {
+        }
+
+
+
+        /// <summary>
+        /// The backing client
+        /// </summary>
+        public IMongoClient Client { get; }
+
+        /// <summary>
+        /// Stores the <see cref="DBContext"/>s managed by this <see cref="MongoContext"/>
+        /// <para>This maps Database name to the matching <see cref="DBContext"/></para>
+        /// </summary>
+        public IDictionary<string, DBContext> Contexts { get; } = new Dictionary<string, DBContext>();
+
+        public ICluster Cluster => Client.Cluster;
+
+        public MongoClientSettings Settings => Client.Settings;
+    }
+
+}

From ff8b6fb0750376352d668b5b475b989364cd3a5a Mon Sep 17 00:00:00 2001
From: Ahmed Fwela <ahmednfwela@bdaya-dev.com>
Date: Fri, 5 Nov 2021 07:34:43 +0200
Subject: [PATCH 03/26] added MongoContextOptions

---
 MongoDB.Entities/Core/MongoContextOptions.cs  | 22 ++++++
 MongoDB.Entities/DB/DB.cs                     |  5 +-
 MongoDB.Entities/DBContext/DBContext.cs       | 26 ++++++-
 .../MongoContext/MongoContext.IMongoClient.cs | 73 +++++++++++--------
 MongoDB.Entities/MongoContext/MongoContext.cs | 39 +++-------
 5 files changed, 101 insertions(+), 64 deletions(-)
 create mode 100644 MongoDB.Entities/Core/MongoContextOptions.cs

diff --git a/MongoDB.Entities/Core/MongoContextOptions.cs b/MongoDB.Entities/Core/MongoContextOptions.cs
new file mode 100644
index 000000000..8403c13eb
--- /dev/null
+++ b/MongoDB.Entities/Core/MongoContextOptions.cs
@@ -0,0 +1,22 @@
+using MongoDB.Driver;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+#nullable enable
+
+namespace MongoDB.Entities
+{
+    public class MongoContextOptions
+    {
+        public MongoContextOptions(ModifiedBy? modifiedBy = null)
+        {
+            ModifiedBy = modifiedBy;
+        }
+
+        /// <summary>
+        /// The value of this property will be automatically set on entities when saving/updating if the entity has a ModifiedBy property
+        /// </summary>
+        public ModifiedBy? ModifiedBy { get; set; }
+    }
+}
diff --git a/MongoDB.Entities/DB/DB.cs b/MongoDB.Entities/DB/DB.cs
index 96f44d4a5..de631e0cc 100644
--- a/MongoDB.Entities/DB/DB.cs
+++ b/MongoDB.Entities/DB/DB.cs
@@ -33,8 +33,9 @@ static DB()
         }
 
         //TODO: refactor api
-
-        //key: FullDBName(including tenant prefix - ex: TenantX~DBName)
+        public static DBContext Context { get; set; }
+
+        //key: FullDBName(including tenant prefix - ex: TenantX~DBName)
         private static readonly ConcurrentDictionary<string, IMongoDatabase> dbs = new();
         private static IMongoDatabase defaultDb;
 
diff --git a/MongoDB.Entities/DBContext/DBContext.cs b/MongoDB.Entities/DBContext/DBContext.cs
index 35be4b99c..84472cecd 100644
--- a/MongoDB.Entities/DBContext/DBContext.cs
+++ b/MongoDB.Entities/DBContext/DBContext.cs
@@ -16,16 +16,36 @@ public partial class DBContext
         /// Returns the session object used for transactions
         /// </summary>
         public IClientSessionHandle Session { get; protected set; }
-        public MongoContext MongoContext { get; set; }
+
+
+        public MongoContext MongoContext { get; }
+
         /// <summary>
-        /// The value of this property will be automatically set on entities when saving/updating if the entity has a ModifiedBy property
+        /// wrapper around <see cref="MongoContext.ModifiedBy"/> so that we don't break the public api
         /// </summary>
-        public ModifiedBy ModifiedBy { get; set; }
+        public ModifiedBy ModifiedBy
+        {
+            get
+            {
+                return MongoContext.ModifiedBy;
+            }
+            set
+            {
+                MongoContext.Options.ModifiedBy = value;
+            }
+        }
+
+
 
         protected string tenantPrefix;
         private static Type[] allEntitiyTypes;
         private Dictionary<Type, (object filterDef, bool prepend)> globalFilters;
 
+        public DBContext(MongoContext mongoContext)
+        {
+            MongoContext = mongoContext;
+        }
+
         /// <summary>
         /// Initializes a DBContext instance with the given connection parameters.
         /// <para>TIP: network connection is deferred until the first actual operation.</para>
diff --git a/MongoDB.Entities/MongoContext/MongoContext.IMongoClient.cs b/MongoDB.Entities/MongoContext/MongoContext.IMongoClient.cs
index ae7a4aa98..879166f26 100644
--- a/MongoDB.Entities/MongoContext/MongoContext.IMongoClient.cs
+++ b/MongoDB.Entities/MongoContext/MongoContext.IMongoClient.cs
@@ -1,5 +1,6 @@
 using MongoDB.Bson;
 using MongoDB.Driver;
+using MongoDB.Driver.Core.Clusters;
 using System;
 using System.Collections.Generic;
 using System.Text;
@@ -8,154 +9,166 @@
 
 namespace MongoDB.Entities
 {
+    //Make these interface implmentation explicit, so we can fine-tune the api return result
     public partial class MongoContext
     {
-        public void DropDatabase(string name, CancellationToken cancellationToken = default)
+        public ICluster Cluster => Client.Cluster;
+
+        public MongoClientSettings Settings => Client.Settings;
+
+        void IMongoClient.DropDatabase(string name, CancellationToken cancellationToken)
         {
             Client.DropDatabase(name, cancellationToken);
         }
 
-        public void DropDatabase(IClientSessionHandle session, string name, CancellationToken cancellationToken = default)
+        void IMongoClient.DropDatabase(IClientSessionHandle session, string name, CancellationToken cancellationToken)
         {
             Client.DropDatabase(session, name, cancellationToken);
         }
 
-        public Task DropDatabaseAsync(string name, CancellationToken cancellationToken = default)
+        Task IMongoClient.DropDatabaseAsync(string name, CancellationToken cancellationToken)
         {
             return Client.DropDatabaseAsync(name, cancellationToken);
         }
 
-        public Task DropDatabaseAsync(IClientSessionHandle session, string name, CancellationToken cancellationToken = default)
+        Task IMongoClient.DropDatabaseAsync(IClientSessionHandle session, string name, CancellationToken cancellationToken)
         {
             return Client.DropDatabaseAsync(session, name, cancellationToken);
         }
 
-        public IMongoDatabase GetDatabase(string name, MongoDatabaseSettings settings = null)
+        IMongoDatabase IMongoClient.GetDatabase(string name, MongoDatabaseSettings settings)
         {
             return Client.GetDatabase(name, settings);
         }
 
-        public IAsyncCursor<string> ListDatabaseNames(CancellationToken cancellationToken = default)
+        IAsyncCursor<string> IMongoClient.ListDatabaseNames(CancellationToken cancellationToken)
         {
             return Client.ListDatabaseNames(cancellationToken);
         }
 
-        public IAsyncCursor<string> ListDatabaseNames(ListDatabaseNamesOptions options, CancellationToken cancellationToken = default)
+        IAsyncCursor<string> IMongoClient.ListDatabaseNames(ListDatabaseNamesOptions options, CancellationToken cancellationToken)
         {
             return Client.ListDatabaseNames(options, cancellationToken);
         }
 
-        public IAsyncCursor<string> ListDatabaseNames(IClientSessionHandle session, CancellationToken cancellationToken = default)
+        IAsyncCursor<string> IMongoClient.ListDatabaseNames(IClientSessionHandle session, CancellationToken cancellationToken)
         {
             return Client.ListDatabaseNames(session, cancellationToken);
         }
 
-        public IAsyncCursor<string> ListDatabaseNames(IClientSessionHandle session, ListDatabaseNamesOptions options, CancellationToken cancellationToken = default)
+        IAsyncCursor<string> IMongoClient.ListDatabaseNames(IClientSessionHandle session, ListDatabaseNamesOptions options, CancellationToken cancellationToken)
         {
             return Client.ListDatabaseNames(session, options, cancellationToken);
         }
 
-        public Task<IAsyncCursor<string>> ListDatabaseNamesAsync(CancellationToken cancellationToken = default)
+        public async Task<List<string>> AllDatabaseNamesAsync()
+        {
+            return await (await
+                   ((IMongoClient)this)
+                   .ListDatabaseNamesAsync().ConfigureAwait(false))
+                   .ToListAsync().ConfigureAwait(false);
+        }
+        Task<IAsyncCursor<string>> IMongoClient.ListDatabaseNamesAsync(CancellationToken cancellationToken)
         {
             return Client.ListDatabaseNamesAsync(cancellationToken);
         }
 
-        public Task<IAsyncCursor<string>> ListDatabaseNamesAsync(ListDatabaseNamesOptions options, CancellationToken cancellationToken = default)
+        Task<IAsyncCursor<string>> IMongoClient.ListDatabaseNamesAsync(ListDatabaseNamesOptions options, CancellationToken cancellationToken)
         {
             return Client.ListDatabaseNamesAsync(options, cancellationToken);
         }
 
-        public Task<IAsyncCursor<string>> ListDatabaseNamesAsync(IClientSessionHandle session, CancellationToken cancellationToken = default)
+        Task<IAsyncCursor<string>> IMongoClient.ListDatabaseNamesAsync(IClientSessionHandle session, CancellationToken cancellationToken)
         {
             return Client.ListDatabaseNamesAsync(session, cancellationToken);
         }
 
-        public Task<IAsyncCursor<string>> ListDatabaseNamesAsync(IClientSessionHandle session, ListDatabaseNamesOptions options, CancellationToken cancellationToken = default)
+        Task<IAsyncCursor<string>> IMongoClient.ListDatabaseNamesAsync(IClientSessionHandle session, ListDatabaseNamesOptions options, CancellationToken cancellationToken)
         {
             return Client.ListDatabaseNamesAsync(session, options, cancellationToken);
         }
 
-        public IAsyncCursor<BsonDocument> ListDatabases(CancellationToken cancellationToken = default)
+        IAsyncCursor<BsonDocument> IMongoClient.ListDatabases(CancellationToken cancellationToken)
         {
             return Client.ListDatabases(cancellationToken);
         }
 
-        public IAsyncCursor<BsonDocument> ListDatabases(ListDatabasesOptions options, CancellationToken cancellationToken = default)
+        IAsyncCursor<BsonDocument> IMongoClient.ListDatabases(ListDatabasesOptions options, CancellationToken cancellationToken)
         {
             return Client.ListDatabases(options, cancellationToken);
         }
 
-        public IAsyncCursor<BsonDocument> ListDatabases(IClientSessionHandle session, CancellationToken cancellationToken = default)
+        IAsyncCursor<BsonDocument> IMongoClient.ListDatabases(IClientSessionHandle session, CancellationToken cancellationToken)
         {
             return Client.ListDatabases(session, cancellationToken);
         }
 
-        public IAsyncCursor<BsonDocument> ListDatabases(IClientSessionHandle session, ListDatabasesOptions options, CancellationToken cancellationToken = default)
+        IAsyncCursor<BsonDocument> IMongoClient.ListDatabases(IClientSessionHandle session, ListDatabasesOptions options, CancellationToken cancellationToken)
         {
             return Client.ListDatabases(session, options, cancellationToken);
         }
 
-        public Task<IAsyncCursor<BsonDocument>> ListDatabasesAsync(CancellationToken cancellationToken = default)
+        Task<IAsyncCursor<BsonDocument>> IMongoClient.ListDatabasesAsync(CancellationToken cancellationToken)
         {
             return Client.ListDatabasesAsync(cancellationToken);
         }
 
-        public Task<IAsyncCursor<BsonDocument>> ListDatabasesAsync(ListDatabasesOptions options, CancellationToken cancellationToken = default)
+        Task<IAsyncCursor<BsonDocument>> IMongoClient.ListDatabasesAsync(ListDatabasesOptions options, CancellationToken cancellationToken)
         {
             return Client.ListDatabasesAsync(options, cancellationToken);
         }
 
-        public Task<IAsyncCursor<BsonDocument>> ListDatabasesAsync(IClientSessionHandle session, CancellationToken cancellationToken = default)
+        Task<IAsyncCursor<BsonDocument>> IMongoClient.ListDatabasesAsync(IClientSessionHandle session, CancellationToken cancellationToken)
         {
             return Client.ListDatabasesAsync(session, cancellationToken);
         }
 
-        public Task<IAsyncCursor<BsonDocument>> ListDatabasesAsync(IClientSessionHandle session, ListDatabasesOptions options, CancellationToken cancellationToken = default)
+        Task<IAsyncCursor<BsonDocument>> IMongoClient.ListDatabasesAsync(IClientSessionHandle session, ListDatabasesOptions options, CancellationToken cancellationToken)
         {
             return Client.ListDatabasesAsync(session, options, cancellationToken);
         }
 
-        public IClientSessionHandle StartSession(ClientSessionOptions options = null, CancellationToken cancellationToken = default)
+        IClientSessionHandle IMongoClient.StartSession(ClientSessionOptions options, CancellationToken cancellationToken)
         {
             return Client.StartSession(options, cancellationToken);
         }
 
-        public Task<IClientSessionHandle> StartSessionAsync(ClientSessionOptions options = null, CancellationToken cancellationToken = default)
+        Task<IClientSessionHandle> IMongoClient.StartSessionAsync(ClientSessionOptions options, CancellationToken cancellationToken)
         {
             return Client.StartSessionAsync(options, cancellationToken);
         }
 
-        public IChangeStreamCursor<TResult> Watch<TResult>(PipelineDefinition<ChangeStreamDocument<BsonDocument>, TResult> pipeline, ChangeStreamOptions options = null, CancellationToken cancellationToken = default)
+        IChangeStreamCursor<TResult> IMongoClient.Watch<TResult>(PipelineDefinition<ChangeStreamDocument<BsonDocument>, TResult> pipeline, ChangeStreamOptions options, CancellationToken cancellationToken)
         {
             return Client.Watch(pipeline, options, cancellationToken);
         }
 
-        public IChangeStreamCursor<TResult> Watch<TResult>(IClientSessionHandle session, PipelineDefinition<ChangeStreamDocument<BsonDocument>, TResult> pipeline, ChangeStreamOptions options = null, CancellationToken cancellationToken = default)
+        IChangeStreamCursor<TResult> IMongoClient.Watch<TResult>(IClientSessionHandle session, PipelineDefinition<ChangeStreamDocument<BsonDocument>, TResult> pipeline, ChangeStreamOptions options, CancellationToken cancellationToken)
         {
             return Client.Watch(session, pipeline, options, cancellationToken);
         }
 
-        public Task<IChangeStreamCursor<TResult>> WatchAsync<TResult>(PipelineDefinition<ChangeStreamDocument<BsonDocument>, TResult> pipeline, ChangeStreamOptions options = null, CancellationToken cancellationToken = default)
+        Task<IChangeStreamCursor<TResult>> IMongoClient.WatchAsync<TResult>(PipelineDefinition<ChangeStreamDocument<BsonDocument>, TResult> pipeline, ChangeStreamOptions options, CancellationToken cancellationToken)
         {
             return Client.WatchAsync(pipeline, options, cancellationToken);
         }
 
-        public Task<IChangeStreamCursor<TResult>> WatchAsync<TResult>(IClientSessionHandle session, PipelineDefinition<ChangeStreamDocument<BsonDocument>, TResult> pipeline, ChangeStreamOptions options = null, CancellationToken cancellationToken = default)
+        Task<IChangeStreamCursor<TResult>> IMongoClient.WatchAsync<TResult>(IClientSessionHandle session, PipelineDefinition<ChangeStreamDocument<BsonDocument>, TResult> pipeline, ChangeStreamOptions options, CancellationToken cancellationToken = default)
         {
             return Client.WatchAsync(session, pipeline, options, cancellationToken);
         }
 
-        public IMongoClient WithReadConcern(ReadConcern readConcern)
+        IMongoClient IMongoClient.WithReadConcern(ReadConcern readConcern)
         {
             return Client.WithReadConcern(readConcern);
         }
 
-        public IMongoClient WithReadPreference(ReadPreference readPreference)
+        IMongoClient IMongoClient.WithReadPreference(ReadPreference readPreference)
         {
             return Client.WithReadPreference(readPreference);
         }
 
-        public IMongoClient WithWriteConcern(WriteConcern writeConcern)
+        IMongoClient IMongoClient.WithWriteConcern(WriteConcern writeConcern)
         {
             return Client.WithWriteConcern(writeConcern);
         }
diff --git a/MongoDB.Entities/MongoContext/MongoContext.cs b/MongoDB.Entities/MongoContext/MongoContext.cs
index 64dd22d9e..7a705074e 100644
--- a/MongoDB.Entities/MongoContext/MongoContext.cs
+++ b/MongoDB.Entities/MongoContext/MongoContext.cs
@@ -1,52 +1,33 @@
 using MongoDB.Driver;
-using MongoDB.Driver.Core.Clusters;
 using System.Collections.Generic;
-
+#nullable enable
 namespace MongoDB.Entities
 {
     /// <summary>
-    /// MongoContext is simply a wrapper around a <see cref="IMongoClient"/>
+    /// MongoContext is a wrapper around an <see cref="IMongoClient"/>
     /// </summary>
     public partial class MongoContext : IMongoClient
     {
         /// <summary>
-        /// Creates a new <see cref="MongoContext"/> from an existing <see cref="IMongoClient"/>
+        /// Creates a new context
         /// </summary>        
-        public MongoContext(IMongoClient client)
+        /// <param name="client">The backing client, usually a <see cref="MongoClient"/></param>
+        /// <param name="options">The options to configure the context</param>
+        public MongoContext(IMongoClient client, MongoContextOptions? options = null)
         {
             Client = client;
+            Options = options ?? new();
         }
 
-        /// <summary>
-        /// Creates a new <see cref="MongoContext"/> and a new <see cref="MongoClient"/> from a <see cref="MongoClientSettings"/> object
-        /// </summary>      
-        public MongoContext(MongoClientSettings settings) : this(new MongoClient(settings))
-        {
-        }
-
-        /// <summary>
-        /// Creates a new <see cref="MongoContext"/>, <see cref="MongoClient"/> and <see cref="MongoClientSettings"/> from a <see cref="MongoUrl"/> object
-        /// </summary>
-        public MongoContext(MongoUrl url) : this(MongoClientSettings.FromUrl(url))
-        {
-        }
-
-
-
         /// <summary>
         /// The backing client
         /// </summary>
         public IMongoClient Client { get; }
 
-        /// <summary>
-        /// Stores the <see cref="DBContext"/>s managed by this <see cref="MongoContext"/>
-        /// <para>This maps Database name to the matching <see cref="DBContext"/></para>
-        /// </summary>
-        public IDictionary<string, DBContext> Contexts { get; } = new Dictionary<string, DBContext>();
-
-        public ICluster Cluster => Client.Cluster;
+        public MongoContextOptions Options { get; set; }
 
-        public MongoClientSettings Settings => Client.Settings;
+        /// <inheritdoc cref="MongoContextOptions.ModifiedBy"/>
+        public ModifiedBy? ModifiedBy => Options.ModifiedBy;
     }
 
 }

From 2db41d00b10326a91fc3b0c87769ac67ac2e0558 Mon Sep 17 00:00:00 2001
From: Ahmed Fwela <ahmednfwela@bdaya-dev.com>
Date: Fri, 5 Nov 2021 09:40:02 +0200
Subject: [PATCH 04/26] WIP moving static implmentations to MongoContext and
 DBContext

---
 MongoDB.Entities/Core/Cache.cs                |  62 ++---
 MongoDB.Entities/Core/DBContextOptions.cs     |  17 ++
 MongoDB.Entities/Core/Entity.cs               |   2 +-
 MongoDB.Entities/Core/FileEntity.cs           |  10 +-
 MongoDB.Entities/DB/DB.Collection.cs          |  37 +--
 MongoDB.Entities/DB/DB.File.cs                |  12 +-
 MongoDB.Entities/DB/DB.cs                     |   6 +-
 .../DBContext/DBContext.Collection.cs         |  33 ++-
 MongoDB.Entities/DBContext/DBContext.Count.cs |   6 +-
 .../DBContext/DBContext.Delete.cs             |  10 +-
 .../DBContext/DBContext.Distinct.cs           |   2 +-
 MongoDB.Entities/DBContext/DBContext.File.cs  |  13 +-
 MongoDB.Entities/DBContext/DBContext.Find.cs  |   4 +-
 .../DBContext/DBContext.Fluent.cs             |   4 +-
 .../DBContext/DBContext.GeoNear.cs            |   2 +-
 .../DBContext/DBContext.IMongoDatabase.cs     | 234 ++++++++++++++++++
 .../DBContext/DBContext.PagedSearch.cs        |   4 +-
 .../DBContext/DBContext.Pipeline.cs           |   2 +-
 .../DBContext/DBContext.Queryable.cs          |   2 +-
 .../DBContext/DBContext.Replace.cs            |   2 +-
 .../DBContext/DBContext.Update.cs             |   4 +-
 MongoDB.Entities/DBContext/DBContext.cs       | 128 +++++-----
 .../MongoContext/MongoContext.IMongoClient.cs |   9 +-
 MongoDB.Entities/MongoContext/MongoContext.cs |  50 ++++
 MongoDB.Entities/MongoDB.Entities.csproj      |   2 +-
 25 files changed, 477 insertions(+), 180 deletions(-)
 create mode 100644 MongoDB.Entities/Core/DBContextOptions.cs
 create mode 100644 MongoDB.Entities/DBContext/DBContext.IMongoDatabase.cs

diff --git a/MongoDB.Entities/Core/Cache.cs b/MongoDB.Entities/Core/Cache.cs
index d7c293bac..75119667c 100644
--- a/MongoDB.Entities/Core/Cache.cs
+++ b/MongoDB.Entities/Core/Cache.cs
@@ -14,19 +14,19 @@ internal abstract class Cache
     {
         //key: entity type
         //val: collection name
-        protected static readonly ConcurrentDictionary<Type, string> typeToCollectionNameMap = new();
+        protected readonly ConcurrentDictionary<Type, string> typeToCollectionNameMap = new();
 
         //key: entity type
         //val: database name without tenant prefix (will be null if not specifically set using DB.DatabaseFor<T>() method)
-        protected static readonly ConcurrentDictionary<Type, string> typeToDbNameWithoutTenantPrefixMap = new();
+        protected readonly ConcurrentDictionary<Type, string> typeToDbNameWithoutTenantPrefixMap = new();
 
-        internal static string CollectionNameFor(Type entityType)
+        internal string CollectionNameFor(Type entityType)
             => typeToCollectionNameMap[entityType];
 
-        internal static void MapTypeToDbNameWithoutTenantPrefix<T>(string dbNameWithoutTenantPrefix) where T : IEntity
+        internal void MapTypeToDbNameWithoutTenantPrefix<T>(string dbNameWithoutTenantPrefix) where T : IEntity
             => typeToDbNameWithoutTenantPrefixMap[typeof(T)] = dbNameWithoutTenantPrefix;
 
-        internal static string GetFullDbName(Type entityType, string tenantPrefix)
+        internal string GetFullDbName(Type entityType, string tenantPrefix)
         {
             string fullDbName = null;
 
@@ -46,22 +46,22 @@ internal static string GetFullDbName(Type entityType, string tenantPrefix)
 
     internal class Cache<T> : Cache where T : IEntity
     {
-        internal static ConcurrentDictionary<string, Watcher<T>> Watchers { get; } = new();
-        internal static bool HasCreatedOn { get; }
-        internal static bool HasModifiedOn { get; }
-        internal static string ModifiedOnPropName { get; }
-        internal static PropertyInfo ModifiedByProp { get; }
-        internal static bool HasIgnoreIfDefaultProps { get; }
-        internal static string CollectionName { get; }
-        internal static bool IsFileEntity { get; }
+        public ConcurrentDictionary<string, Watcher<T>> Watchers { get; } = new();
+        public bool HasCreatedOn { get; }
+        public bool HasModifiedOn { get; }
+        public string ModifiedOnPropName { get; }
+        public PropertyInfo ModifiedByProp { get; }
+        public bool HasIgnoreIfDefaultProps { get; }
+        public string CollectionName { get; }
+        public bool IsFileEntity { get; }
 
         //key: TenantPrefix:CollectionName
         //val: IMongoCollection<T>
-        private static readonly ConcurrentDictionary<string, IMongoCollection<T>> cache = new();
-        private static readonly PropertyInfo[] updatableProps;
-        private static ProjectionDefinition<T> requiredPropsProjection;
+        private readonly ConcurrentDictionary<string, IMongoCollection<T>> _cache = new();
+        private readonly PropertyInfo[] _updatableProps;
+        private ProjectionDefinition<T> _requiredPropsProjection;
 
-        static Cache()
+        public Cache()
         {
             var type = typeof(T);
             var interfaces = type.GetInterfaces();
@@ -83,20 +83,20 @@ static Cache()
             ModifiedOnPropName = nameof(IModifiedOn.ModifiedOn);
             IsFileEntity = type.BaseType == typeof(FileEntity);
 
-            updatableProps = type.GetProperties()
+            _updatableProps = type.GetProperties()
                 .Where(p =>
                        p.PropertyType.Name != ManyBase.PropTypeName &&
                       !p.IsDefined(typeof(BsonIdAttribute), false) &&
                       !p.IsDefined(typeof(BsonIgnoreAttribute), false))
                 .ToArray();
 
-            HasIgnoreIfDefaultProps = updatableProps.Any(p =>
+            HasIgnoreIfDefaultProps = _updatableProps.Any(p =>
                     p.IsDefined(typeof(BsonIgnoreIfDefaultAttribute), false) ||
                     p.IsDefined(typeof(BsonIgnoreIfNullAttribute), false));
 
             try
             {
-                ModifiedByProp = updatableProps.SingleOrDefault(p =>
+                ModifiedByProp = _updatableProps.SingleOrDefault(p =>
                                 p.PropertyType == typeof(ModifiedBy) ||
                                 p.PropertyType.IsSubclassOf(typeof(ModifiedBy)));
             }
@@ -106,32 +106,32 @@ static Cache()
             }
         }
 
-        internal static IMongoCollection<T> Collection(string tenantPrefix)
+        public IMongoCollection<T> Collection(string tenantPrefix)
         {
-            return cache.GetOrAdd(
+            return _cache.GetOrAdd(
                 key: $"{tenantPrefix}:{CollectionName}",
                 valueFactory: _ => DB.Database(GetFullDbName(typeof(T), tenantPrefix)).GetCollection<T>(CollectionName));
         }
 
-        internal static IEnumerable<PropertyInfo> UpdatableProps(T entity)
+        public IEnumerable<PropertyInfo> UpdatableProps(T entity)
         {
             if (HasIgnoreIfDefaultProps)
             {
-                return updatableProps.Where(p =>
+                return _updatableProps.Where(p =>
                     !(p.IsDefined(typeof(BsonIgnoreIfDefaultAttribute), false) && p.GetValue(entity) == default) &&
                     !(p.IsDefined(typeof(BsonIgnoreIfNullAttribute), false) && p.GetValue(entity) == null));
             }
-            return updatableProps;
+            return _updatableProps;
         }
 
-        internal static ProjectionDefinition<T, TProjection> CombineWithRequiredProps<TProjection>(ProjectionDefinition<T, TProjection> userProjection)
+        public ProjectionDefinition<T, TProjection> CombineWithRequiredProps<TProjection>(ProjectionDefinition<T, TProjection> userProjection)
         {
             if (userProjection == null)
                 throw new InvalidOperationException("Please use .Project() method before .IncludeRequiredProps()");
 
-            if (requiredPropsProjection is null)
+            if (_requiredPropsProjection is null)
             {
-                requiredPropsProjection = "{_id:1}";
+                _requiredPropsProjection = "{_id:1}";
 
                 var props = typeof(T)
                     .GetProperties()
@@ -146,9 +146,9 @@ internal static ProjectionDefinition<T, TProjection> CombineWithRequiredProps<TP
                     attr = p.GetCustomAttribute<FieldAttribute>();
 
                     if (attr is null)
-                        requiredPropsProjection = requiredPropsProjection.Include(p.Name);
+                        _requiredPropsProjection = _requiredPropsProjection.Include(p.Name);
                     else
-                        requiredPropsProjection = requiredPropsProjection.Include(attr.ElementName);
+                        _requiredPropsProjection = _requiredPropsProjection.Include(attr.ElementName);
                 }
             }
 
@@ -158,7 +158,7 @@ internal static ProjectionDefinition<T, TProjection> CombineWithRequiredProps<TP
 
             return Builders<T>.Projection.Combine(new[]
             {
-                requiredPropsProjection,
+                _requiredPropsProjection,
                 userProj
             });
         }
diff --git a/MongoDB.Entities/Core/DBContextOptions.cs b/MongoDB.Entities/Core/DBContextOptions.cs
new file mode 100644
index 000000000..a0571e7ee
--- /dev/null
+++ b/MongoDB.Entities/Core/DBContextOptions.cs
@@ -0,0 +1,17 @@
+#nullable enable
+
+using MongoDB.Driver;
+
+namespace MongoDB.Entities
+{
+    public class DBContextOptions
+    {
+        public DBContextOptions(string? tenantId = null)
+        {
+            TenantId = tenantId;
+        }
+
+        public string? TenantId { get; set; }
+        
+    }
+}
diff --git a/MongoDB.Entities/Core/Entity.cs b/MongoDB.Entities/Core/Entity.cs
index bc1975b14..a7b7b5073 100644
--- a/MongoDB.Entities/Core/Entity.cs
+++ b/MongoDB.Entities/Core/Entity.cs
@@ -7,7 +7,7 @@ namespace MongoDB.Entities
     /// Inherit this class for all entities you want to store in their own collection.
     /// </summary>
     public abstract class Entity : IEntity
-    {
+    {        
         /// <summary>
         /// This property is auto managed. A new ID will be assigned for new entities upon saving.
         /// </summary>
diff --git a/MongoDB.Entities/Core/FileEntity.cs b/MongoDB.Entities/Core/FileEntity.cs
index 47103c57c..beb2dc732 100644
--- a/MongoDB.Entities/Core/FileEntity.cs
+++ b/MongoDB.Entities/Core/FileEntity.cs
@@ -43,13 +43,11 @@ public abstract class FileEntity : Entity
         [IgnoreDefault]
         public string MD5 { get; set; }
 
-        [IgnoreDefault]
-        public string TenantPrefix { get; set; }
 
         /// <summary>
         /// Access the DataStreamer class for uploading and downloading data
         /// </summary>
-        public DataStreamer Data => streamer ??= new DataStreamer(this, TenantPrefix);
+        public DataStreamer Data => streamer ??= new DataStreamer(this);
     }
 
     [Collection("[BINARY_CHUNKS]")]
@@ -76,7 +74,7 @@ public class DataStreamer
 
         private readonly FileEntity parent;
         private readonly Type parentType;
-        private readonly IMongoDatabase db;
+        private readonly DBContext db;
         private readonly IMongoCollection<FileChunk> chunkCollection;
         private FileChunk doc;
         private int chunkSize, readCount;
@@ -84,11 +82,11 @@ public class DataStreamer
         private List<byte> dataChunk;
         private MD5 md5;
 
-        internal DataStreamer(FileEntity parent, string tenantPrefix)
+        internal DataStreamer(FileEntity parent, DBContext db)
         {
             this.parent = parent;
             parentType = parent.GetType();
-            db = DB.Database(Cache.GetFullDbName(parentType, tenantPrefix));
+            this.db = db;
             chunkCollection = db.GetCollection<FileChunk>(DB.CollectionName<FileChunk>());
 
             if (indexedDBs.Add(db.DatabaseNamespace.DatabaseName))
diff --git a/MongoDB.Entities/DB/DB.Collection.cs b/MongoDB.Entities/DB/DB.Collection.cs
index c26147333..da292a4d4 100644
--- a/MongoDB.Entities/DB/DB.Collection.cs
+++ b/MongoDB.Entities/DB/DB.Collection.cs
@@ -39,15 +39,9 @@ public static string CollectionName<T>() where T : IEntity
         /// <typeparam name="T">The type of entity that will be stored in the created collection</typeparam>
         /// <param name="options">The options to use for collection creation</param>
         /// <param name="cancellation">An optional cancellation token</param>
-        /// <param name="session">An optional session if using within a transaction</param>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static Task CreateCollectionAsync<T>(Action<CreateCollectionOptions<T>> options, CancellationToken cancellation = default, IClientSessionHandle session = null, string tenantPrefix = null) where T : IEntity
+        public static Task CreateCollectionAsync<T>(Action<CreateCollectionOptions<T>> options, CancellationToken cancellation = default) where T : IEntity
         {
-            var opts = new CreateCollectionOptions<T>();
-            options(opts);
-            return session == null
-                   ? Cache<T>.Collection(tenantPrefix).Database.CreateCollectionAsync(Cache<T>.CollectionName, opts, cancellation)
-                   : Cache<T>.Collection(tenantPrefix).Database.CreateCollectionAsync(session, Cache<T>.CollectionName, opts, cancellation);
+            return Context.CreateCollectionAsync(options, cancellation);
         }
 
         /// <summary>
@@ -55,32 +49,9 @@ public static Task CreateCollectionAsync<T>(Action<CreateCollectionOptions<T>> o
         /// <para>TIP: When deleting a collection, all relationships associated with that entity type is also deleted.</para>
         /// </summary>
         /// <typeparam name="T">The entity type to drop the collection of</typeparam>
-        /// <param name="session">An optional session if using within a transaction</param>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static async Task DropCollectionAsync<T>(IClientSessionHandle session = null, string tenantPrefix = null) where T : IEntity
+        public static async Task DropCollectionAsync<T>() where T : IEntity
         {
-            var tasks = new List<Task>();
-            var db = Database<T>(tenantPrefix);
-            var collName = CollectionName<T>();
-            var options = new ListCollectionNamesOptions
-            {
-                Filter = "{$and:[{name:/~/},{name:/" + collName + "/}]}"
-            };
-
-            foreach (var cName in await db.ListCollectionNames(options).ToListAsync().ConfigureAwait(false))
-            {
-                tasks.Add(
-                    session == null
-                    ? db.DropCollectionAsync(cName)
-                    : db.DropCollectionAsync(session, cName));
-            }
-
-            tasks.Add(
-                session == null
-                ? db.DropCollectionAsync(collName)
-                : db.DropCollectionAsync(session, collName));
-
-            await Task.WhenAll(tasks).ConfigureAwait(false);
+            await Context.DropCollectionAsync<T>();
         }
     }
 }
diff --git a/MongoDB.Entities/DB/DB.File.cs b/MongoDB.Entities/DB/DB.File.cs
index 778a872cc..89af177f1 100644
--- a/MongoDB.Entities/DB/DB.File.cs
+++ b/MongoDB.Entities/DB/DB.File.cs
@@ -9,16 +9,10 @@ public static partial class DB
         /// Returns a DataStreamer object to enable uploading/downloading file data directly by supplying the ID of the file entity
         /// </summary>
         /// <typeparam name="T">The file entity type</typeparam>
-        /// <param name="ID">The ID of the file entity</param>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static DataStreamer File<T>(string ID, string tenantPrefix = null) where T : FileEntity, new()
+        /// <param name="ID">The ID of the file entity</param>        
+        public static DataStreamer File<T>(string ID) where T : FileEntity, new()
         {
-            if (!ObjectId.TryParse(ID, out _))
-                throw new ArgumentException("The ID passed in is not of the correct format!");
-
-            return new DataStreamer(
-                new T() { ID = ID, UploadSuccessful = true },
-                tenantPrefix);
+            return Context.File<T>(ID);
         }
     }
 }
diff --git a/MongoDB.Entities/DB/DB.cs b/MongoDB.Entities/DB/DB.cs
index de631e0cc..499fbcdc4 100644
--- a/MongoDB.Entities/DB/DB.cs
+++ b/MongoDB.Entities/DB/DB.cs
@@ -33,11 +33,7 @@ static DB()
         }
 
         //TODO: refactor api
-        public static DBContext Context { get; set; }
-
-        //key: FullDBName(including tenant prefix - ex: TenantX~DBName)
-        private static readonly ConcurrentDictionary<string, IMongoDatabase> dbs = new();
-        private static IMongoDatabase defaultDb;
+        public static DBContext Context { get; set; }
 
         /// <summary>
         /// Initializes a MongoDB connection with the given connection parameters.
diff --git a/MongoDB.Entities/DBContext/DBContext.Collection.cs b/MongoDB.Entities/DBContext/DBContext.Collection.cs
index 916db93bc..7399448f3 100644
--- a/MongoDB.Entities/DBContext/DBContext.Collection.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Collection.cs
@@ -1,5 +1,6 @@
 using MongoDB.Driver;
 using System;
+using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -15,7 +16,12 @@ public partial class DBContext
         /// <param name="cancellation">An optional cancellation token</param>
         public Task CreateCollectionAsync<T>(Action<CreateCollectionOptions<T>> options, CancellationToken cancellation = default) where T : IEntity
         {
-            return DB.CreateCollectionAsync(options, cancellation, Session, tenantPrefix);
+            var opts = new CreateCollectionOptions<T>();
+            options(opts);
+            return Session == null
+                  ? Database.CreateCollectionAsync(Cache<T>.CollectionName, opts, cancellation)
+                  : Database.CreateCollectionAsync(Session, Cache<T>.CollectionName, opts, cancellation);
+
         }
 
         /// <summary>
@@ -23,9 +29,30 @@ public Task CreateCollectionAsync<T>(Action<CreateCollectionOptions<T>> options,
         /// <para>TIP: When deleting a collection, all relationships associated with that entity type is also deleted.</para>
         /// </summary>
         /// <typeparam name="T">The entity type to drop the collection of</typeparam>
-        public Task DropCollectionAsync<T>() where T : IEntity
+        public async Task DropCollectionAsync<T>() where T : IEntity
         {
-            return DB.DropCollectionAsync<T>(Session, tenantPrefix);
+            var tasks = new List<Task>();
+            var db = Database;
+            var collName = Cache<T>.CollectionName;
+            var options = new ListCollectionNamesOptions
+            {
+                Filter = "{$and:[{name:/~/},{name:/" + collName + "/}]}"
+            };
+
+            foreach (var cName in await db.ListCollectionNames(options).ToListAsync().ConfigureAwait(false))
+            {
+                tasks.Add(
+                    Session == null
+                    ? db.DropCollectionAsync(cName)
+                    : db.DropCollectionAsync(Session, cName));
+            }
+
+            tasks.Add(
+                Session == null
+                ? db.DropCollectionAsync(collName)
+                : db.DropCollectionAsync(Session, collName));
+
+            await Task.WhenAll(tasks).ConfigureAwait(false);
         }
     }
 }
diff --git a/MongoDB.Entities/DBContext/DBContext.Count.cs b/MongoDB.Entities/DBContext/DBContext.Count.cs
index eae348754..ba593a507 100644
--- a/MongoDB.Entities/DBContext/DBContext.Count.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Count.cs
@@ -30,7 +30,7 @@ public Task<long> CountEstimatedAsync<T>(CancellationToken cancellation = defaul
         public Task<long> CountAsync<T>(Expression<Func<T, bool>> expression, CancellationToken cancellation = default, CountOptions options = null, bool ignoreGlobalFilters = false) where T : IEntity
         {
             return DB.CountAsync(
-                Logic.MergeWithGlobalFilter<T>(ignoreGlobalFilters, globalFilters, expression),
+                Logic.MergeWithGlobalFilter<T>(ignoreGlobalFilters, _globalFilters, expression),
                 Session,
                 cancellation,
                 options,
@@ -58,7 +58,7 @@ public Task<long> CountAsync<T>(CancellationToken cancellation = default) where
         public Task<long> CountAsync<T>(FilterDefinition<T> filter, CancellationToken cancellation = default, CountOptions options = null, bool ignoreGlobalFilters = false) where T : IEntity
         {
             return DB.CountAsync(
-                Logic.MergeWithGlobalFilter(ignoreGlobalFilters, globalFilters, filter),
+                Logic.MergeWithGlobalFilter(ignoreGlobalFilters, _globalFilters, filter),
                 Session,
                 cancellation,
                 options,
@@ -76,7 +76,7 @@ public Task<long> CountAsync<T>(FilterDefinition<T> filter, CancellationToken ca
         public Task<long> CountAsync<T>(Func<FilterDefinitionBuilder<T>, FilterDefinition<T>> filter, CancellationToken cancellation = default, CountOptions options = null, bool ignoreGlobalFilters = false) where T : IEntity
         {
             return DB.CountAsync(
-                Logic.MergeWithGlobalFilter(ignoreGlobalFilters, globalFilters, filter(Builders<T>.Filter)),
+                Logic.MergeWithGlobalFilter(ignoreGlobalFilters, _globalFilters, filter(Builders<T>.Filter)),
                 Session,
                 cancellation,
                 options,
diff --git a/MongoDB.Entities/DBContext/DBContext.Delete.cs b/MongoDB.Entities/DBContext/DBContext.Delete.cs
index edaa9062a..e5567f1c9 100644
--- a/MongoDB.Entities/DBContext/DBContext.Delete.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Delete.cs
@@ -20,7 +20,7 @@ public partial class DBContext
         public Task<DeleteResult> DeleteAsync<T>(string ID, CancellationToken cancellation = default, bool ignoreGlobalFilters = false) where T : IEntity
         {
             return DB.DeleteAsync(
-                Logic.MergeWithGlobalFilter(ignoreGlobalFilters, globalFilters, Builders<T>.Filter.Eq(e => e.ID, ID)),
+                Logic.MergeWithGlobalFilter(ignoreGlobalFilters, _globalFilters, Builders<T>.Filter.Eq(e => e.ID, ID)),
                 Session,
                 cancellation,
                 tenantPrefix: tenantPrefix);
@@ -38,7 +38,7 @@ public Task<DeleteResult> DeleteAsync<T>(string ID, CancellationToken cancellati
         public Task<DeleteResult> DeleteAsync<T>(IEnumerable<string> IDs, CancellationToken cancellation = default, bool ignoreGlobalFilters = false) where T : IEntity
         {
             return DB.DeleteAsync(
-                Logic.MergeWithGlobalFilter(ignoreGlobalFilters, globalFilters, Builders<T>.Filter.In(e => e.ID, IDs)),
+                Logic.MergeWithGlobalFilter(ignoreGlobalFilters, _globalFilters, Builders<T>.Filter.In(e => e.ID, IDs)),
                 Session,
                 cancellation,
                 tenantPrefix: tenantPrefix);
@@ -57,7 +57,7 @@ public Task<DeleteResult> DeleteAsync<T>(IEnumerable<string> IDs, CancellationTo
         public Task<DeleteResult> DeleteAsync<T>(Expression<Func<T, bool>> expression, CancellationToken cancellation = default, Collation collation = null, bool ignoreGlobalFilters = false) where T : IEntity
         {
             return DB.DeleteAsync(
-                Logic.MergeWithGlobalFilter(ignoreGlobalFilters, globalFilters, Builders<T>.Filter.Where(expression)),
+                Logic.MergeWithGlobalFilter(ignoreGlobalFilters, _globalFilters, Builders<T>.Filter.Where(expression)),
                 Session,
                 cancellation,
                 collation,
@@ -77,7 +77,7 @@ public Task<DeleteResult> DeleteAsync<T>(Expression<Func<T, bool>> expression, C
         public Task<DeleteResult> DeleteAsync<T>(Func<FilterDefinitionBuilder<T>, FilterDefinition<T>> filter, CancellationToken cancellation = default, Collation collation = null, bool ignoreGlobalFilters = false) where T : IEntity
         {
             return DB.DeleteAsync(
-                Logic.MergeWithGlobalFilter(ignoreGlobalFilters, globalFilters, filter(Builders<T>.Filter)),
+                Logic.MergeWithGlobalFilter(ignoreGlobalFilters, _globalFilters, filter(Builders<T>.Filter)),
                 Session,
                 cancellation,
                 collation,
@@ -97,7 +97,7 @@ public Task<DeleteResult> DeleteAsync<T>(Func<FilterDefinitionBuilder<T>, Filter
         public Task<DeleteResult> DeleteAsync<T>(FilterDefinition<T> filter, CancellationToken cancellation = default, Collation collation = null, bool ignoreGlobalFilters = false) where T : IEntity
         {
             return DB.DeleteAsync(
-                Logic.MergeWithGlobalFilter(ignoreGlobalFilters, globalFilters, filter),
+                Logic.MergeWithGlobalFilter(ignoreGlobalFilters, _globalFilters, filter),
                 Session,
                 cancellation,
                 collation,
diff --git a/MongoDB.Entities/DBContext/DBContext.Distinct.cs b/MongoDB.Entities/DBContext/DBContext.Distinct.cs
index 6507371f1..c6eaa71a8 100644
--- a/MongoDB.Entities/DBContext/DBContext.Distinct.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Distinct.cs
@@ -9,7 +9,7 @@ public partial class DBContext
         /// <typeparam name="TProperty">The type of the property of the entity you'd like to get unique values for</typeparam>
         public Distinct<T, TProperty> Distinct<T, TProperty>() where T : IEntity
         {
-            return new Distinct<T, TProperty>(Session, globalFilters, tenantPrefix);
+            return new Distinct<T, TProperty>(Session, _globalFilters, tenantPrefix);
         }
     }
 }
diff --git a/MongoDB.Entities/DBContext/DBContext.File.cs b/MongoDB.Entities/DBContext/DBContext.File.cs
index 34b3ec23f..956066a22 100644
--- a/MongoDB.Entities/DBContext/DBContext.File.cs
+++ b/MongoDB.Entities/DBContext/DBContext.File.cs
@@ -1,4 +1,7 @@
-namespace MongoDB.Entities
+using MongoDB.Bson;
+using System;
+
+namespace MongoDB.Entities
 {
     public partial class DBContext
     {
@@ -9,7 +12,13 @@ public partial class DBContext
         /// <param name="ID">The ID of the file entity</param>
         public DataStreamer File<T>(string ID) where T : FileEntity, new()
         {
-            return DB.File<T>(ID, tenantPrefix);
+            if (!ObjectId.TryParse(ID, out _))
+                throw new ArgumentException("The ID passed in is not of the correct format!");
+
+            return new DataStreamer(
+                new T() { ID = ID, UploadSuccessful = true },
+                tenantPrefix);
+            return File<T>(ID);
         }
     }
 }
diff --git a/MongoDB.Entities/DBContext/DBContext.Find.cs b/MongoDB.Entities/DBContext/DBContext.Find.cs
index a3d7d957b..7a1f9fe35 100644
--- a/MongoDB.Entities/DBContext/DBContext.Find.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Find.cs
@@ -8,7 +8,7 @@ public partial class DBContext
         /// <typeparam name="T">The type of entity</typeparam>
         public Find<T> Find<T>() where T : IEntity
         {
-            return new Find<T>(Session, globalFilters, tenantPrefix);
+            return new Find<T>(Session, _globalFilters, tenantPrefix);
         }
 
         /// <summary>
@@ -18,7 +18,7 @@ public Find<T> Find<T>() where T : IEntity
         /// <typeparam name="TProjection">The type of the end result</typeparam>
         public Find<T, TProjection> Find<T, TProjection>() where T : IEntity
         {
-            return new Find<T, TProjection>(Session, globalFilters, tenantPrefix);
+            return new Find<T, TProjection>(Session, _globalFilters, tenantPrefix);
         }
     }
 }
diff --git a/MongoDB.Entities/DBContext/DBContext.Fluent.cs b/MongoDB.Entities/DBContext/DBContext.Fluent.cs
index 9b4f9a86b..fbfda43ae 100644
--- a/MongoDB.Entities/DBContext/DBContext.Fluent.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Fluent.cs
@@ -12,7 +12,7 @@ public partial class DBContext
         /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
         public IAggregateFluent<T> Fluent<T>(AggregateOptions options = null, bool ignoreGlobalFilters = false) where T : IEntity
         {
-            var globalFilter = Logic.MergeWithGlobalFilter(ignoreGlobalFilters, globalFilters, Builders<T>.Filter.Empty);
+            var globalFilter = Logic.MergeWithGlobalFilter(ignoreGlobalFilters, _globalFilters, Builders<T>.Filter.Empty);
 
             if (globalFilter != Builders<T>.Filter.Empty)
             {
@@ -37,7 +37,7 @@ public IAggregateFluent<T> Fluent<T>(AggregateOptions options = null, bool ignor
         /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
         public IAggregateFluent<T> FluentTextSearch<T>(Search searchType, string searchTerm, bool caseSensitive = false, bool diacriticSensitive = false, string language = null, AggregateOptions options = null, bool ignoreGlobalFilters = false) where T : IEntity
         {
-            var globalFilter = Logic.MergeWithGlobalFilter(ignoreGlobalFilters, globalFilters, Builders<T>.Filter.Empty);
+            var globalFilter = Logic.MergeWithGlobalFilter(ignoreGlobalFilters, _globalFilters, Builders<T>.Filter.Empty);
 
             if (globalFilter != Builders<T>.Filter.Empty)
             {
diff --git a/MongoDB.Entities/DBContext/DBContext.GeoNear.cs b/MongoDB.Entities/DBContext/DBContext.GeoNear.cs
index d944fba74..87bed9b59 100644
--- a/MongoDB.Entities/DBContext/DBContext.GeoNear.cs
+++ b/MongoDB.Entities/DBContext/DBContext.GeoNear.cs
@@ -25,7 +25,7 @@ public partial class DBContext
         /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
         public IAggregateFluent<T> GeoNear<T>(Coordinates2D NearCoordinates, Expression<Func<T, object>> DistanceField, bool Spherical = true, int? MaxDistance = null, int? MinDistance = null, int? Limit = null, BsonDocument Query = null, int? DistanceMultiplier = null, Expression<Func<T, object>> IncludeLocations = null, string IndexKey = null, AggregateOptions options = null, bool ignoreGlobalFilters = false) where T : IEntity
         {
-            var globalFilter = Logic.MergeWithGlobalFilter(ignoreGlobalFilters, globalFilters, Builders<T>.Filter.Empty);
+            var globalFilter = Logic.MergeWithGlobalFilter(ignoreGlobalFilters, _globalFilters, Builders<T>.Filter.Empty);
 
             if (globalFilter != Builders<T>.Filter.Empty)
             {
diff --git a/MongoDB.Entities/DBContext/DBContext.IMongoDatabase.cs b/MongoDB.Entities/DBContext/DBContext.IMongoDatabase.cs
new file mode 100644
index 000000000..73a2cdbea
--- /dev/null
+++ b/MongoDB.Entities/DBContext/DBContext.IMongoDatabase.cs
@@ -0,0 +1,234 @@
+using MongoDB.Bson.Serialization;
+using MongoDB.Driver;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Threading;
+using System.Threading.Tasks;
+#nullable enable
+namespace MongoDB.Entities
+{
+    public partial class DBContext
+    {
+        IAsyncCursor<TResult> IMongoDatabase.Aggregate<TResult>(PipelineDefinition<NoPipelineInput, TResult> pipeline, AggregateOptions options, CancellationToken cancellationToken)
+        {
+            return Database.Aggregate(pipeline, options, cancellationToken);
+        }
+
+        IAsyncCursor<TResult> IMongoDatabase.Aggregate<TResult>(IClientSessionHandle session, PipelineDefinition<NoPipelineInput, TResult> pipeline, AggregateOptions options, CancellationToken cancellationToken)
+        {
+            return Database.Aggregate(session, pipeline, options, cancellationToken);
+        }
+
+        Task<IAsyncCursor<TResult>> IMongoDatabase.AggregateAsync<TResult>(PipelineDefinition<NoPipelineInput, TResult> pipeline, AggregateOptions options, CancellationToken cancellationToken)
+        {
+            return Database.AggregateAsync(pipeline, options, cancellationToken);
+        }
+
+        Task<IAsyncCursor<TResult>> IMongoDatabase.AggregateAsync<TResult>(IClientSessionHandle session, PipelineDefinition<NoPipelineInput, TResult> pipeline, AggregateOptions options, CancellationToken cancellationToken)
+        {
+            return Database.AggregateAsync(session, pipeline, options, cancellationToken);
+        }
+
+        public void AggregateToCollection<TResult>(PipelineDefinition<NoPipelineInput, TResult> pipeline, AggregateOptions? options = null, CancellationToken cancellationToken = default)
+        {
+            Database.AggregateToCollection(pipeline, options, cancellationToken);
+        }
+
+        public void AggregateToCollection<TResult>(IClientSessionHandle session, PipelineDefinition<NoPipelineInput, TResult> pipeline, AggregateOptions? options = null, CancellationToken cancellationToken = default)
+        {
+            Database.AggregateToCollection(session, pipeline, options, cancellationToken);
+        }
+
+        public Task AggregateToCollectionAsync<TResult>(PipelineDefinition<NoPipelineInput, TResult> pipeline, AggregateOptions? options = null, CancellationToken cancellationToken = default)
+        {
+            return Database.AggregateToCollectionAsync(pipeline, options, cancellationToken);
+        }
+
+        public Task AggregateToCollectionAsync<TResult>(IClientSessionHandle session, PipelineDefinition<NoPipelineInput, TResult> pipeline, AggregateOptions? options = null, CancellationToken cancellationToken = default)
+        {
+            return Database.AggregateToCollectionAsync(session, pipeline, options, cancellationToken);
+        }
+
+        public void CreateCollection(string name, CreateCollectionOptions? options = null, CancellationToken cancellationToken = default)
+        {
+            Database.CreateCollection(name, options, cancellationToken);
+        }
+
+        public void CreateCollection(IClientSessionHandle session, string name, CreateCollectionOptions options, CancellationToken cancellationToken)
+        {
+            Database.CreateCollection(session, name, options, cancellationToken);
+        }
+
+        public Task CreateCollectionAsync(string name, CreateCollectionOptions options, CancellationToken cancellationToken)
+        {
+            return Database.CreateCollectionAsync(name, options, cancellationToken);
+        }
+
+        public Task CreateCollectionAsync(IClientSessionHandle session, string name, CreateCollectionOptions options, CancellationToken cancellationToken)
+        {
+            return Database.CreateCollectionAsync(session, name, options, cancellationToken);
+        }
+
+        public void CreateView<TDocument, TResult>(string viewName, string viewOn, PipelineDefinition<TDocument, TResult> pipeline, CreateViewOptions<TDocument> options, CancellationToken cancellationToken)
+        {
+            Database.CreateView(viewName, viewOn, pipeline, options, cancellationToken);
+        }
+
+        public void CreateView<TDocument, TResult>(IClientSessionHandle session, string viewName, string viewOn, PipelineDefinition<TDocument, TResult> pipeline, CreateViewOptions<TDocument> options, CancellationToken cancellationToken)
+        {
+            Database.CreateView(session, viewName, viewOn, pipeline, options, cancellationToken);
+        }
+
+        public Task CreateViewAsync<TDocument, TResult>(string viewName, string viewOn, PipelineDefinition<TDocument, TResult> pipeline, CreateViewOptions<TDocument> options, CancellationToken cancellationToken)
+        {
+            return Database.CreateViewAsync(viewName, viewOn, pipeline, options, cancellationToken);
+        }
+
+        public Task CreateViewAsync<TDocument, TResult>(IClientSessionHandle session, string viewName, string viewOn, PipelineDefinition<TDocument, TResult> pipeline, CreateViewOptions<TDocument> options, CancellationToken cancellationToken)
+        {
+            return Database.CreateViewAsync(session, viewName, viewOn, pipeline, options, cancellationToken);
+        }
+
+        public void DropCollection(string name, CancellationToken cancellationToken = default)
+        {
+            Database.DropCollection(name, cancellationToken);
+        }
+
+        public void DropCollection(IClientSessionHandle session, string name, CancellationToken cancellationToken = default)
+        {
+            Database.DropCollection(session, name, cancellationToken);
+        }
+
+        public Task DropCollectionAsync(string name, CancellationToken cancellationToken = default)
+        {
+            return Database.DropCollectionAsync(name, cancellationToken);
+        }
+
+        public Task DropCollectionAsync(IClientSessionHandle session, string name, CancellationToken cancellationToken = default)
+        {
+            return Database.DropCollectionAsync(session, name, cancellationToken);
+        }
+
+        public IMongoCollection<TDocument> GetCollection<TDocument>(string name, MongoCollectionSettings? settings = null)
+        {
+            return Database.GetCollection<TDocument>(name, settings);
+        }
+
+        IAsyncCursor<string> IMongoDatabase.ListCollectionNames(ListCollectionNamesOptions options, CancellationToken cancellationToken)
+        {
+            return Database.ListCollectionNames(options, cancellationToken);
+        }
+
+        IAsyncCursor<string> IMongoDatabase.ListCollectionNames(IClientSessionHandle session, ListCollectionNamesOptions options, CancellationToken cancellationToken)
+        {
+            return Database.ListCollectionNames(session, options, cancellationToken);
+        }
+
+        Task<IAsyncCursor<string>> IMongoDatabase.ListCollectionNamesAsync(ListCollectionNamesOptions options, CancellationToken cancellationToken)
+        {
+            return Database.ListCollectionNamesAsync(options, cancellationToken);
+        }
+
+        Task<IAsyncCursor<string>> IMongoDatabase.ListCollectionNamesAsync(IClientSessionHandle session, ListCollectionNamesOptions options, CancellationToken cancellationToken)
+        {
+            return Database.ListCollectionNamesAsync(session, options, cancellationToken);
+        }
+
+        IAsyncCursor<Bson.BsonDocument> IMongoDatabase.ListCollections(ListCollectionsOptions options, CancellationToken cancellationToken)
+        {
+            return Database.ListCollections(options, cancellationToken);
+        }
+
+        IAsyncCursor<Bson.BsonDocument> IMongoDatabase.ListCollections(IClientSessionHandle session, ListCollectionsOptions options, CancellationToken cancellationToken)
+        {
+            return Database.ListCollections(session, options, cancellationToken);
+        }
+
+        Task<IAsyncCursor<Bson.BsonDocument>> IMongoDatabase.ListCollectionsAsync(ListCollectionsOptions options, CancellationToken cancellationToken)
+        {
+            return Database.ListCollectionsAsync(options, cancellationToken);
+        }
+
+        Task<IAsyncCursor<Bson.BsonDocument>> IMongoDatabase.ListCollectionsAsync(IClientSessionHandle session, ListCollectionsOptions options, CancellationToken cancellationToken)
+        {
+            return Database.ListCollectionsAsync(session, options, cancellationToken);
+        }
+
+        void IMongoDatabase.RenameCollection(string oldName, string newName, RenameCollectionOptions options, CancellationToken cancellationToken)
+        {
+            Database.RenameCollection(oldName, newName, options, cancellationToken);
+        }
+
+        void IMongoDatabase.RenameCollection(IClientSessionHandle session, string oldName, string newName, RenameCollectionOptions options, CancellationToken cancellationToken)
+        {
+            Database.RenameCollection(session, oldName, newName, options, cancellationToken);
+        }
+
+        Task IMongoDatabase.RenameCollectionAsync(string oldName, string newName, RenameCollectionOptions options, CancellationToken cancellationToken)
+        {
+            return Database.RenameCollectionAsync(oldName, newName, options, cancellationToken);
+        }
+
+        Task IMongoDatabase.RenameCollectionAsync(IClientSessionHandle session, string oldName, string newName, RenameCollectionOptions options, CancellationToken cancellationToken)
+        {
+            return Database.RenameCollectionAsync(session, oldName, newName, options, cancellationToken);
+        }
+
+        TResult IMongoDatabase.RunCommand<TResult>(Command<TResult> command, ReadPreference readPreference, CancellationToken cancellationToken)
+        {
+            return Database.RunCommand(command, readPreference, cancellationToken);
+        }
+
+        TResult IMongoDatabase.RunCommand<TResult>(IClientSessionHandle session, Command<TResult> command, ReadPreference readPreference, CancellationToken cancellationToken)
+        {
+            return Database.RunCommand(session, command, readPreference, cancellationToken);
+        }
+
+        Task<TResult> IMongoDatabase.RunCommandAsync<TResult>(Command<TResult> command, ReadPreference readPreference, CancellationToken cancellationToken)
+        {
+            return Database.RunCommandAsync(command, readPreference, cancellationToken);
+        }
+
+        Task<TResult> IMongoDatabase.RunCommandAsync<TResult>(IClientSessionHandle session, Command<TResult> command, ReadPreference readPreference, CancellationToken cancellationToken)
+        {
+            return Database.RunCommandAsync(session, command, readPreference, cancellationToken);
+        }
+
+        IChangeStreamCursor<TResult> IMongoDatabase.Watch<TResult>(PipelineDefinition<ChangeStreamDocument<Bson.BsonDocument>, TResult> pipeline, ChangeStreamOptions options, CancellationToken cancellationToken)
+        {
+            return Database.Watch(pipeline, options, cancellationToken);
+        }
+
+        IChangeStreamCursor<TResult> IMongoDatabase.Watch<TResult>(IClientSessionHandle session, PipelineDefinition<ChangeStreamDocument<Bson.BsonDocument>, TResult> pipeline, ChangeStreamOptions options, CancellationToken cancellationToken)
+        {
+            return Database.Watch(session, pipeline, options, cancellationToken);
+        }
+
+        Task<IChangeStreamCursor<TResult>> IMongoDatabase.WatchAsync<TResult>(PipelineDefinition<ChangeStreamDocument<Bson.BsonDocument>, TResult> pipeline, ChangeStreamOptions options, CancellationToken cancellationToken)
+        {
+            return Database.WatchAsync(pipeline, options, cancellationToken);
+        }
+
+        Task<IChangeStreamCursor<TResult>> IMongoDatabase.WatchAsync<TResult>(IClientSessionHandle session, PipelineDefinition<ChangeStreamDocument<Bson.BsonDocument>, TResult> pipeline, ChangeStreamOptions options, CancellationToken cancellationToken)
+        {
+            return Database.WatchAsync(session, pipeline, options, cancellationToken);
+        }
+
+        IMongoDatabase IMongoDatabase.WithReadConcern(ReadConcern readConcern)
+        {
+            return Database.WithReadConcern(readConcern);
+        }
+
+        IMongoDatabase IMongoDatabase.WithReadPreference(ReadPreference readPreference)
+        {
+            return Database.WithReadPreference(readPreference);
+        }
+
+        IMongoDatabase IMongoDatabase.WithWriteConcern(WriteConcern writeConcern)
+        {
+            return Database.WithWriteConcern(writeConcern);
+        }
+    }
+}
diff --git a/MongoDB.Entities/DBContext/DBContext.PagedSearch.cs b/MongoDB.Entities/DBContext/DBContext.PagedSearch.cs
index ced6c1e30..99818fb0c 100644
--- a/MongoDB.Entities/DBContext/DBContext.PagedSearch.cs
+++ b/MongoDB.Entities/DBContext/DBContext.PagedSearch.cs
@@ -8,7 +8,7 @@ public partial class DBContext
         /// <typeparam name="T">Any class that implements IEntity</typeparam>
         public PagedSearch<T> PagedSearch<T>() where T : IEntity
         {
-            return new PagedSearch<T>(Session, globalFilters, tenantPrefix);
+            return new PagedSearch<T>(Session, _globalFilters, tenantPrefix);
         }
 
         /// <summary>
@@ -18,7 +18,7 @@ public PagedSearch<T> PagedSearch<T>() where T : IEntity
         /// <typeparam name="TProjection">The type you'd like to project the results to.</typeparam>
         public PagedSearch<T, TProjection> PagedSearch<T, TProjection>() where T : IEntity
         {
-            return new PagedSearch<T, TProjection>(Session, globalFilters, tenantPrefix);
+            return new PagedSearch<T, TProjection>(Session, _globalFilters, tenantPrefix);
         }
     }
 }
diff --git a/MongoDB.Entities/DBContext/DBContext.Pipeline.cs b/MongoDB.Entities/DBContext/DBContext.Pipeline.cs
index c160b2351..6ea5e01f7 100644
--- a/MongoDB.Entities/DBContext/DBContext.Pipeline.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Pipeline.cs
@@ -74,7 +74,7 @@ private Template<T, TResult> MergeGlobalFilter<T, TResult>(Template<T, TResult>
             //WARNING: this has to do the same thing as Logic.MergeGlobalFilter method
             //         if the following logic changes, update the other method also
 
-            if (!ignoreGlobalFilters && globalFilters.Count > 0 && globalFilters.TryGetValue(typeof(T), out var gFilter))
+            if (!ignoreGlobalFilters && _globalFilters.Count > 0 && _globalFilters.TryGetValue(typeof(T), out var gFilter))
             {
                 BsonDocument filter = null;
 
diff --git a/MongoDB.Entities/DBContext/DBContext.Queryable.cs b/MongoDB.Entities/DBContext/DBContext.Queryable.cs
index 74a88a6a6..6dda35e32 100644
--- a/MongoDB.Entities/DBContext/DBContext.Queryable.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Queryable.cs
@@ -13,7 +13,7 @@ public partial class DBContext
         /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
         public IMongoQueryable<T> Queryable<T>(AggregateOptions options = null, bool ignoreGlobalFilters = false) where T : IEntity
         {
-            var globalFilter = Logic.MergeWithGlobalFilter(ignoreGlobalFilters, globalFilters, Builders<T>.Filter.Empty);
+            var globalFilter = Logic.MergeWithGlobalFilter(ignoreGlobalFilters, _globalFilters, Builders<T>.Filter.Empty);
 
             if (globalFilter != Builders<T>.Filter.Empty)
             {
diff --git a/MongoDB.Entities/DBContext/DBContext.Replace.cs b/MongoDB.Entities/DBContext/DBContext.Replace.cs
index 9ef9d9511..f8eb9e984 100644
--- a/MongoDB.Entities/DBContext/DBContext.Replace.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Replace.cs
@@ -10,7 +10,7 @@ public partial class DBContext
         public Replace<T> Replace<T>() where T : IEntity
         {
             ThrowIfModifiedByIsEmpty<T>();
-            return new Replace<T>(Session, ModifiedBy, globalFilters, OnBeforeSave<T>(), tenantPrefix);
+            return new Replace<T>(Session, ModifiedBy, _globalFilters, OnBeforeSave<T>(), tenantPrefix);
         }
     }
 }
diff --git a/MongoDB.Entities/DBContext/DBContext.Update.cs b/MongoDB.Entities/DBContext/DBContext.Update.cs
index 785d4ed7d..e7ef641d0 100644
--- a/MongoDB.Entities/DBContext/DBContext.Update.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Update.cs
@@ -8,7 +8,7 @@ public partial class DBContext
         /// <typeparam name="T">The type of entity</typeparam>
         public Update<T> Update<T>() where T : IEntity
         {
-            var cmd = new Update<T>(Session, globalFilters, OnBeforeUpdate<T>(), tenantPrefix);
+            var cmd = new Update<T>(Session, _globalFilters, OnBeforeUpdate<T>(), tenantPrefix);
             if (Cache<T>.ModifiedByProp != null)
             {
                 ThrowIfModifiedByIsEmpty<T>();
@@ -33,7 +33,7 @@ public UpdateAndGet<T, T> UpdateAndGet<T>() where T : IEntity
         /// <typeparam name="TProjection">The type of the end result</typeparam>
         public UpdateAndGet<T, TProjection> UpdateAndGet<T, TProjection>() where T : IEntity
         {
-            var cmd = new UpdateAndGet<T, TProjection>(Session, globalFilters, OnBeforeUpdate<T>(), tenantPrefix);
+            var cmd = new UpdateAndGet<T, TProjection>(Session, _globalFilters, OnBeforeUpdate<T>(), tenantPrefix);
             if (Cache<T>.ModifiedByProp != null)
             {
                 ThrowIfModifiedByIsEmpty<T>();
diff --git a/MongoDB.Entities/DBContext/DBContext.cs b/MongoDB.Entities/DBContext/DBContext.cs
index 84472cecd..1aea7d8b9 100644
--- a/MongoDB.Entities/DBContext/DBContext.cs
+++ b/MongoDB.Entities/DBContext/DBContext.cs
@@ -4,46 +4,71 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Linq.Expressions;
-
+using System.Threading;
+using System.Threading.Tasks;
+#nullable enable
 namespace MongoDB.Entities
 {
     /// <summary>
     /// This db context class can be used as an alternative entry point instead of the DB static class. 
     /// </summary>
-    public partial class DBContext
+    public partial class DBContext : IMongoDatabase
     {
         /// <summary>
         /// Returns the session object used for transactions
         /// </summary>
-        public IClientSessionHandle Session { get; protected set; }
+        public IClientSessionHandle? Session { get; protected set; }
 
 
-        public MongoContext MongoContext { get; }
+        public MongoContext MongoContext { get; set; }
+        public IMongoDatabase Database { get; set; }
+        public DBContextOptions Options { get; set; }
 
         /// <summary>
         /// wrapper around <see cref="MongoContext.ModifiedBy"/> so that we don't break the public api
         /// </summary>
-        public ModifiedBy ModifiedBy
+        public ModifiedBy? ModifiedBy
         {
             get
             {
                 return MongoContext.ModifiedBy;
             }
+            [Obsolete("Use MongoContext.Options.ModifiedBy = value instead")]
             set
             {
                 MongoContext.Options.ModifiedBy = value;
             }
         }
 
+        public IMongoClient Client => MongoContext;
+
+        public DatabaseNamespace DatabaseNamespace => Database.DatabaseNamespace;
 
+        public MongoDatabaseSettings Settings => Database.Settings;
 
-        protected string tenantPrefix;
-        private static Type[] allEntitiyTypes;
-        private Dictionary<Type, (object filterDef, bool prepend)> globalFilters;
+        private Dictionary<Type, (object filterDef, bool prepend)> _globalFilters = new();
 
-        public DBContext(MongoContext mongoContext)
+        /// <summary>
+        /// Copy constructor
+        /// </summary>
+        /// <param name="other"></param>
+        public DBContext(DBContext other)
+        {
+            MongoContext = other.MongoContext;
+            Database = other.Database;
+            Options = other.Options;
+        }
+        public DBContext(MongoContext mongoContext, IMongoDatabase database, DBContextOptions? options = null)
         {
             MongoContext = mongoContext;
+            Database = database;
+            Options = options ?? new();
+        }
+        public DBContext(MongoContext mongoContext, string database, MongoDatabaseSettings? settings = null, DBContextOptions? options = null)
+        {
+            MongoContext = mongoContext;
+            Database = mongoContext.GetDatabase(database, settings);
+            Options = options ?? new();
         }
 
         /// <summary>
@@ -57,16 +82,20 @@ public DBContext(MongoContext mongoContext)
         /// When supplied, all save/update operations performed via this DBContext instance will set the value on entities that has a property of type ModifiedBy. 
         /// You can even inherit from the ModifiedBy class and add your own properties to it. 
         /// Only one ModifiedBy property is allowed on a single entity type.</param>
-        public DBContext(string database, string host = "127.0.0.1", int port = 27017, ModifiedBy modifiedBy = null)
+        public DBContext(string database, string host = "127.0.0.1", int port = 27017, ModifiedBy? modifiedBy = null)
         {
-            DB.Initialize(
-                new MongoClientSettings { Server = new MongoServerAddress(host, port) },
-                database,
-                true)
-              .GetAwaiter()
-              .GetResult();
-
-            ModifiedBy = modifiedBy;
+            MongoContext = new MongoContext(
+                client: new MongoClient(
+                    new MongoClientSettings
+                    {
+                        Server = new MongoServerAddress(host, port)
+                    }),
+                options: new()
+                {
+                    ModifiedBy = modifiedBy
+                });
+            Database = MongoContext.GetDatabase(database);
+            Options = new();
         }
 
         /// <summary>
@@ -79,15 +108,19 @@ public DBContext(string database, string host = "127.0.0.1", int port = 27017, M
         /// When supplied, all save/update operations performed via this DBContext instance will set the value on entities that has a property of type ModifiedBy. 
         /// You can even inherit from the ModifiedBy class and add your own properties to it. 
         /// Only one ModifiedBy property is allowed on a single entity type.</param>
-        public DBContext(string database, MongoClientSettings settings, ModifiedBy modifiedBy = null)
+        public DBContext(string database, MongoClientSettings settings, ModifiedBy? modifiedBy = null)
         {
-            DB.Initialize(settings, database, true)
-              .GetAwaiter()
-              .GetResult();
-
-            ModifiedBy = modifiedBy;
+            MongoContext = new MongoContext(
+               client: new MongoClient(settings),
+               options: new()
+               {
+                   ModifiedBy = modifiedBy
+               });
+            Database = MongoContext.GetDatabase(database);
+            Options = new();
         }
 
+
         /// <summary>
         /// Instantiates a DBContext instance
         /// <para>TIP: will throw an error if no connections have been initialized</para>
@@ -96,16 +129,17 @@ public DBContext(string database, MongoClientSettings settings, ModifiedBy modif
         /// When supplied, all save/update operations performed via this DBContext instance will set the value on entities that has a property of type ModifiedBy. 
         /// You can even inherit from the ModifiedBy class and add your own properties to it. 
         /// Only one ModifiedBy property is allowed on a single entity type.</param>
-        public DBContext(ModifiedBy modifiedBy = null)
-            => ModifiedBy = modifiedBy;
-
+        [Obsolete("This constructor is obsolete, you can only create a DBContext after knowing the database name")]
+        public DBContext(ModifiedBy? modifiedBy = null) : this("default", modifiedBy: modifiedBy)
+        {
+        }
 
 
         /// <summary>
         /// This event hook will be trigged right before an entity is persisted
         /// </summary>
         /// <typeparam name="T">Any entity that implements IEntity</typeparam>
-        protected virtual Action<T> OnBeforeSave<T>() where T : IEntity
+        protected virtual Action<T>? OnBeforeSave<T>() where T : IEntity
         {
             return null;
         }
@@ -114,7 +148,7 @@ protected virtual Action<T> OnBeforeSave<T>() where T : IEntity
         /// This event hook will be triggered right before an update/replace command is executed
         /// </summary>
         /// <typeparam name="T">Any entity that implements IEntity</typeparam>
-        protected virtual Action<UpdateBase<T>> OnBeforeUpdate<T>() where T : IEntity
+        protected virtual Action<UpdateBase<T>>? OnBeforeUpdate<T>() where T : IEntity
         {
             return null;
         }
@@ -197,9 +231,7 @@ protected void SetGlobalFilterForBaseClass<TBase>(Func<FilterDefinitionBuilder<T
         /// <param name="prepend">Set to true if you want to prepend this global filter to your operation filters instead of being appended</param>
         protected void SetGlobalFilterForBaseClass<TBase>(FilterDefinition<TBase> filter, bool prepend = false) where TBase : IEntity
         {
-            if (allEntitiyTypes is null) allEntitiyTypes = GetAllEntityTypes();
-
-            foreach (var entType in allEntitiyTypes.Where(t => t.IsSubclassOf(typeof(TBase))))
+            foreach (var entType in MongoContext.AllEntitiyTypes.Where(t => t.IsSubclassOf(typeof(TBase))))
             {
                 var bsonDoc = filter.Render(
                     BsonSerializer.SerializerRegistry.GetSerializer<TBase>(),
@@ -221,9 +253,8 @@ protected void SetGlobalFilterForInterface<TInterface>(string jsonString, bool p
 
             if (!targetType.IsInterface) throw new ArgumentException("Only interfaces are allowed!", "TInterface");
 
-            if (allEntitiyTypes is null) allEntitiyTypes = GetAllEntityTypes();
 
-            foreach (var entType in allEntitiyTypes.Where(t => targetType.IsAssignableFrom(t)))
+            foreach (var entType in MongoContext.AllEntitiyTypes.Where(t => targetType.IsAssignableFrom(t)))
             {
                 AddFilter(entType, (jsonString, prepend));
             }
@@ -231,33 +262,10 @@ protected void SetGlobalFilterForInterface<TInterface>(string jsonString, bool p
 
 
 
-        private static Type[] GetAllEntityTypes()
-        {
-            var excludes = new[]
-                {
-                    "Microsoft.",
-                    "System.",
-                    "MongoDB.",
-                    "testhost.",
-                    "netstandard",
-                    "Newtonsoft.",
-                    "mscorlib",
-                    "NuGet."
-                };
-
-            return AppDomain.CurrentDomain
-                .GetAssemblies()
-                .Where(a =>
-                      !a.IsDynamic &&
-                      (a.FullName.StartsWith("MongoDB.Entities.Tests") || !excludes.Any(n => a.FullName.StartsWith(n))))
-                .SelectMany(a => a.GetTypes())
-                .Where(t => typeof(IEntity).IsAssignableFrom(t))
-                .ToArray();
-        }
 
         private void ThrowIfModifiedByIsEmpty<T>() where T : IEntity
         {
-            if (Cache<T>.ModifiedByProp != null && ModifiedBy is null)
+            if (Cache<T>().ModifiedByProp != null && ModifiedBy is null)
             {
                 throw new InvalidOperationException(
                     $"A value for [{Cache<T>.ModifiedByProp.Name}] must be specified when saving/updating entities of type [{Cache<T>.CollectionName}]");
@@ -266,9 +274,9 @@ private void ThrowIfModifiedByIsEmpty<T>() where T : IEntity
 
         private void AddFilter(Type type, (object filterDef, bool prepend) filter)
         {
-            if (globalFilters is null) globalFilters = new Dictionary<Type, (object filterDef, bool prepend)>();
+            if (_globalFilters is null) _globalFilters = new Dictionary<Type, (object filterDef, bool prepend)>();
 
-            globalFilters[type] = filter;
+            _globalFilters[type] = filter;
         }
     }
 }
diff --git a/MongoDB.Entities/MongoContext/MongoContext.IMongoClient.cs b/MongoDB.Entities/MongoContext/MongoContext.IMongoClient.cs
index 879166f26..90abdd0c7 100644
--- a/MongoDB.Entities/MongoContext/MongoContext.IMongoClient.cs
+++ b/MongoDB.Entities/MongoContext/MongoContext.IMongoClient.cs
@@ -36,7 +36,7 @@ Task IMongoClient.DropDatabaseAsync(IClientSessionHandle session, string name, C
             return Client.DropDatabaseAsync(session, name, cancellationToken);
         }
 
-        IMongoDatabase IMongoClient.GetDatabase(string name, MongoDatabaseSettings settings)
+        public IMongoDatabase GetDatabase(string name, MongoDatabaseSettings settings = null)
         {
             return Client.GetDatabase(name, settings);
         }
@@ -61,13 +61,6 @@ IAsyncCursor<string> IMongoClient.ListDatabaseNames(IClientSessionHandle session
             return Client.ListDatabaseNames(session, options, cancellationToken);
         }
 
-        public async Task<List<string>> AllDatabaseNamesAsync()
-        {
-            return await (await
-                   ((IMongoClient)this)
-                   .ListDatabaseNamesAsync().ConfigureAwait(false))
-                   .ToListAsync().ConfigureAwait(false);
-        }
         Task<IAsyncCursor<string>> IMongoClient.ListDatabaseNamesAsync(CancellationToken cancellationToken)
         {
             return Client.ListDatabaseNamesAsync(cancellationToken);
diff --git a/MongoDB.Entities/MongoContext/MongoContext.cs b/MongoDB.Entities/MongoContext/MongoContext.cs
index 7a705074e..a10bd78c2 100644
--- a/MongoDB.Entities/MongoContext/MongoContext.cs
+++ b/MongoDB.Entities/MongoContext/MongoContext.cs
@@ -1,5 +1,9 @@
 using MongoDB.Driver;
+using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
 #nullable enable
 namespace MongoDB.Entities
 {
@@ -28,6 +32,52 @@ public MongoContext(IMongoClient client, MongoContextOptions? options = null)
 
         /// <inheritdoc cref="MongoContextOptions.ModifiedBy"/>
         public ModifiedBy? ModifiedBy => Options.ModifiedBy;
+
+        public async Task<List<string>> AllDatabaseNamesAsync()
+        {
+            return await (await
+                   ((IMongoClient)this)
+                   .ListDatabaseNamesAsync().ConfigureAwait(false))
+                   .ToListAsync().ConfigureAwait(false);
+        }
+
+        private Type[]? _allEntitiyTypes;
+        public Type[] AllEntitiyTypes => _allEntitiyTypes ??= GetAllEntityTypes();
+
+        private readonly ConcurrentDictionary<Type, Cache> _cache = new();
+        internal Cache<T> Cache<T>() where T : IEntity
+        {
+            if (!_cache.TryGetValue(typeof(T), out var c))
+            {
+                c = new Cache<T>();
+            }
+            return (Cache<T>)c;
+        }
+
+        private static Type[] GetAllEntityTypes()
+        {
+            var excludes = new[]
+                {
+                    "Microsoft.",
+                    "System.",
+                    "MongoDB.",
+                    "testhost.",
+                    "netstandard",
+                    "Newtonsoft.",
+                    "mscorlib",
+                    "NuGet."
+                };
+
+            return AppDomain.CurrentDomain
+                .GetAssemblies()
+                .Where(a =>
+                      !a.IsDynamic &&
+                      (a.FullName.StartsWith("MongoDB.Entities.Tests") || !excludes.Any(n => a.FullName.StartsWith(n))))
+                .SelectMany(a => a.GetTypes())
+                .Where(t => typeof(IEntity).IsAssignableFrom(t))
+                .ToArray();
+        }
+
     }
 
 }
diff --git a/MongoDB.Entities/MongoDB.Entities.csproj b/MongoDB.Entities/MongoDB.Entities.csproj
index a22fa9a34..c038c070e 100644
--- a/MongoDB.Entities/MongoDB.Entities.csproj
+++ b/MongoDB.Entities/MongoDB.Entities.csproj
@@ -11,7 +11,7 @@
       - upgrade dependencies
     </PackageReleaseNotes>
 
-    <TargetFramework>netstandard2.0</TargetFramework>
+    <TargetFramework>netstandard2.1</TargetFramework>
     <RootNamespace>MongoDB.Entities</RootNamespace>
     <AssemblyName>MongoDB.Entities</AssemblyName>
     <Authors>Đĵ ΝιΓΞΗΛψΚ</Authors>

From e4d479a12e7db395ef6acb2b32e67517a1a1a26d Mon Sep 17 00:00:00 2001
From: Ahmed Fwela <ahmednfwela@bdaya-dev.com>
Date: Fri, 5 Nov 2021 09:56:14 +0200
Subject: [PATCH 05/26] revert back TargetFramework

---
 MongoDB.Entities/MongoDB.Entities.csproj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/MongoDB.Entities/MongoDB.Entities.csproj b/MongoDB.Entities/MongoDB.Entities.csproj
index c038c070e..a22fa9a34 100644
--- a/MongoDB.Entities/MongoDB.Entities.csproj
+++ b/MongoDB.Entities/MongoDB.Entities.csproj
@@ -11,7 +11,7 @@
       - upgrade dependencies
     </PackageReleaseNotes>
 
-    <TargetFramework>netstandard2.1</TargetFramework>
+    <TargetFramework>netstandard2.0</TargetFramework>
     <RootNamespace>MongoDB.Entities</RootNamespace>
     <AssemblyName>MongoDB.Entities</AssemblyName>
     <Authors>Đĵ ΝιΓΞΗΛψΚ</Authors>

From c4d43761efc75e7b80e087b139fb1431f8017d3a Mon Sep 17 00:00:00 2001
From: Ahmed Fwela <ahmednfwela@bdaya-dev.com>
Date: Fri, 5 Nov 2021 14:28:29 +0200
Subject: [PATCH 06/26] Better find

---
 MongoDB.Entities/Builders/Find.cs | 303 ++++++++++++++++--------------
 1 file changed, 165 insertions(+), 138 deletions(-)

diff --git a/MongoDB.Entities/Builders/Find.cs b/MongoDB.Entities/Builders/Find.cs
index 6405f7c39..946972f64 100644
--- a/MongoDB.Entities/Builders/Find.cs
+++ b/MongoDB.Entities/Builders/Find.cs
@@ -7,89 +7,36 @@
 using System.Linq.Expressions;
 using System.Threading;
 using System.Threading.Tasks;
-
+#nullable enable
 namespace MongoDB.Entities
 {
-    /// <summary>
-    /// Represents a MongoDB Find command.
-    /// <para>TIP: Specify your criteria using .Match() .Sort() .Skip() .Take() .Project() .Option() methods and finally call .Execute()</para>
-    /// <para>Note: For building queries, use the DB.Fluent* interfaces</para>
-    /// </summary>
-    /// <typeparam name="T">Any class that implements IEntity</typeparam>
-    public class Find<T> : Find<T, T> where T : IEntity
-    {
-        internal Find(
-            IClientSessionHandle session,
-            Dictionary<Type, (object filterDef, bool prepend)> globalFilters, string tenantPrefix)
-            : base(session, globalFilters, tenantPrefix) { }
-    }
-
-    /// <summary>
-    /// Represents a MongoDB Find command with the ability to project to a different result type.
-    /// <para>TIP: Specify your criteria using .Match() .Sort() .Skip() .Take() .Project() .Option() methods and finally call .Execute()</para>
-    /// </summary>
-    /// <typeparam name="T">Any class that implements IEntity</typeparam>
-    /// <typeparam name="TProjection">The type you'd like to project the results to.</typeparam>
-    public class Find<T, TProjection> where T : IEntity
+    public class FindBase<T, TProjection, TSelf> where T : IEntity where TSelf : FindBase<T, TProjection, TSelf>
     {
-        private FilterDefinition<T> filter = Builders<T>.Filter.Empty;
-        private readonly List<SortDefinition<T>> sorts = new();
-        private readonly FindOptions<T, TProjection> options = new();
-        private readonly IClientSessionHandle session;
-        private readonly Dictionary<Type, (object filterDef, bool prepend)> globalFilters;
-        private bool ignoreGlobalFilters;
-        private readonly string tenantPrefix;
+        internal FilterDefinition<T> _filter = Builders<T>.Filter.Empty;
+        internal List<SortDefinition<T>> _sorts = new();
+        internal FindOptions<T, TProjection> _options = new();
+        internal Dictionary<Type, (object filterDef, bool prepend)> _globalFilters;
+        internal bool _ignoreGlobalFilters;
 
-        internal Find(
-            IClientSessionHandle session,
-            Dictionary<Type, (object filterDef, bool prepend)> globalFilters, string tenantPrefix)
+        internal FindBase(FindBase<T, TProjection, TSelf> other) : this(globalFilters: other._globalFilters)
         {
-            this.session = session;
-            this.globalFilters = globalFilters;
-            this.tenantPrefix = tenantPrefix;
+            _filter = other._filter;
+            _options = other._options;
+            _sorts = other._sorts;
+            _ignoreGlobalFilters = other._ignoreGlobalFilters;
         }
-
-        /// <summary>
-        /// Find a single IEntity by ID
-        /// </summary>
-        /// <param name="ID">The unique ID of an IEntity</param>
-        /// <param name="cancellation">An optional cancellation token</param>
-        /// <returns>A single entity or null if not found</returns>
-        public Task<TProjection> OneAsync(string ID, CancellationToken cancellation = default)
-        {
-            Match(ID);
-            return ExecuteSingleAsync(cancellation);
-        }
-
-        /// <summary>
-        /// Find entities by supplying a lambda expression
-        /// </summary>
-        /// <param name="expression">x => x.Property == Value</param>
-        /// <param name="cancellation">An optional cancellation token</param>
-        /// <returns>A list of Entities</returns>
-        public Task<List<TProjection>> ManyAsync(Expression<Func<T, bool>> expression, CancellationToken cancellation = default)
+        internal FindBase(Dictionary<Type, (object filterDef, bool prepend)> globalFilters)
         {
-            Match(expression);
-            return ExecuteAsync(cancellation);
+            _globalFilters = globalFilters;
         }
 
-        /// <summary>
-        /// Find entities by supplying a filter expression
-        /// </summary>
-        /// <param name="filter">f => f.Eq(x => x.Prop, Value) &amp; f.Gt(x => x.Prop, Value)</param>
-        /// <param name="cancellation">An optional cancellation token</param>
-        /// <returns>A list of Entities</returns>
-        public Task<List<TProjection>> ManyAsync(Func<FilterDefinitionBuilder<T>, FilterDefinition<T>> filter, CancellationToken cancellation = default)
-        {
-            Match(filter);
-            return ExecuteAsync(cancellation);
-        }
+        private TSelf This => (TSelf)this;
 
         /// <summary>
         /// Specify an IEntity ID as the matching criteria
         /// </summary>
         /// <param name="ID">A unique IEntity ID</param>
-        public Find<T, TProjection> MatchID(string ID)
+        public TSelf MatchID(string ID)
         {
             return Match(f => f.Eq(t => t.ID, ID));
         }
@@ -98,7 +45,7 @@ public Find<T, TProjection> MatchID(string ID)
         /// Specify an IEntity ID as the matching criteria
         /// </summary>
         /// <param name="ID">A unique IEntity ID</param>
-        public Find<T, TProjection> Match(string ID)
+        public TSelf Match(string ID)
         {
             return Match(f => f.Eq(t => t.ID, ID));
         }
@@ -107,7 +54,7 @@ public Find<T, TProjection> Match(string ID)
         /// Specify the matching criteria with a lambda expression
         /// </summary>
         /// <param name="expression">x => x.Property == Value</param>
-        public Find<T, TProjection> Match(Expression<Func<T, bool>> expression)
+        public TSelf Match(Expression<Func<T, bool>> expression)
         {
             return Match(f => f.Where(expression));
         }
@@ -116,30 +63,30 @@ public Find<T, TProjection> Match(Expression<Func<T, bool>> expression)
         /// Specify the matching criteria with a filter expression
         /// </summary>
         /// <param name="filter">f => f.Eq(x => x.Prop, Value) &amp; f.Gt(x => x.Prop, Value)</param>
-        public Find<T, TProjection> Match(Func<FilterDefinitionBuilder<T>, FilterDefinition<T>> filter)
+        public TSelf Match(Func<FilterDefinitionBuilder<T>, FilterDefinition<T>> filter)
         {
-            this.filter &= filter(Builders<T>.Filter);
-            return this;
+            _filter &= filter(Builders<T>.Filter);
+            return This;
         }
 
         /// <summary>
         /// Specify the matching criteria with a filter definition
         /// </summary>
         /// <param name="filterDefinition">A filter definition</param>
-        public Find<T, TProjection> Match(FilterDefinition<T> filterDefinition)
+        public TSelf Match(FilterDefinition<T> filterDefinition)
         {
-            filter &= filterDefinition;
-            return this;
+            _filter &= filterDefinition;
+            return This;
         }
 
         /// <summary>
         /// Specify the matching criteria with a template
         /// </summary>
         /// <param name="template">A Template with a find query</param>
-        public Find<T, TProjection> Match(Template template)
+        public TSelf Match(Template template)
         {
-            filter &= template.RenderToString();
-            return this;
+            _filter &= template.RenderToString();
+            return This;
         }
 
         /// <summary>
@@ -151,7 +98,7 @@ public Find<T, TProjection> Match(Template template)
         /// <param name="caseSensitive">Case sensitivity of the search (optional)</param>
         /// <param name="diacriticSensitive">Diacritic sensitivity of the search (optional)</param>
         /// <param name="language">The language for the search (optional)</param>
-        public Find<T, TProjection> Match(Search searchType, string searchTerm, bool caseSensitive = false, bool diacriticSensitive = false, string language = null)
+        public TSelf Match(Search searchType, string searchTerm, bool caseSensitive = false, bool diacriticSensitive = false, string? language = null)
         {
             if (searchType == Search.Fuzzy)
             {
@@ -181,7 +128,7 @@ public Find<T, TProjection> Match(Search searchType, string searchTerm, bool cas
         /// <param name="nearCoordinates">The search point</param>
         /// <param name="maxDistance">Maximum distance in meters from the search point</param>
         /// <param name="minDistance">Minimum distance in meters from the search point</param>
-        public Find<T, TProjection> Match(Expression<Func<T, object>> coordinatesProperty, Coordinates2D nearCoordinates, double? maxDistance = null, double? minDistance = null)
+        public TSelf Match(Expression<Func<T, object>> coordinatesProperty, Coordinates2D nearCoordinates, double? maxDistance = null, double? minDistance = null)
         {
             return Match(f => f.Near(coordinatesProperty, nearCoordinates.ToGeoJsonPoint(), maxDistance, minDistance));
         }
@@ -190,30 +137,29 @@ public Find<T, TProjection> Match(Expression<Func<T, object>> coordinatesPropert
         /// Specify the matching criteria with a JSON string
         /// </summary>
         /// <param name="jsonString">{ Title : 'The Power Of Now' }</param>
-        public Find<T, TProjection> MatchString(string jsonString)
+        public TSelf MatchString(string jsonString)
         {
-            filter &= jsonString;
-            return this;
+            _filter &= jsonString;
+            return This;
         }
 
         /// <summary>
         /// Specify the matching criteria with an aggregation expression (i.e. $expr)
         /// </summary>
         /// <param name="expression">{ $gt: ['$Property1', '$Property2'] }</param>
-        public Find<T, TProjection> MatchExpression(string expression)
+        public TSelf MatchExpression(string expression)
         {
-            filter &= "{$expr:" + expression + "}";
-            return this;
+            _filter &= "{$expr:" + expression + "}";
+            return This;
         }
 
         /// <summary>
         /// Specify the matching criteria with a Template
         /// </summary>
         /// <param name="template">A Template object</param>
-        public Find<T, TProjection> MatchExpression(Template template)
+        public TSelf MatchExpression(Template template)
         {
-            filter &= "{$expr:" + template.RenderToString() + "}";
-            return this;
+            return MatchExpression(template.RenderToString());
         }
 
         /// <summary>
@@ -221,13 +167,13 @@ public Find<T, TProjection> MatchExpression(Template template)
         /// </summary>
         /// <param name="propertyToSortBy">x => x.Prop</param>
         /// <param name="sortOrder">The sort order</param>
-        public Find<T, TProjection> Sort(Expression<Func<T, object>> propertyToSortBy, Order sortOrder)
+        public TSelf Sort(Expression<Func<T, object>> propertyToSortBy, Order sortOrder)
         {
             return sortOrder switch
             {
                 Order.Ascending => Sort(s => s.Ascending(propertyToSortBy)),
                 Order.Descending => Sort(s => s.Descending(propertyToSortBy)),
-                _ => this,
+                _ => This,
             };
         }
 
@@ -235,7 +181,7 @@ public Find<T, TProjection> Sort(Expression<Func<T, object>> propertyToSortBy, O
         /// Sort the results of a text search by the MetaTextScore
         /// <para>TIP: Use this method after .Project() if you need to do a projection also</para>
         /// </summary>
-        public Find<T, TProjection> SortByTextScore()
+        public TSelf SortByTextScore()
         {
             return SortByTextScore(null);
         }
@@ -245,7 +191,7 @@ public Find<T, TProjection> SortByTextScore()
         /// <para>TIP: Use this method after .Project() if you need to do a projection also</para>
         /// </summary>
         /// <param name="scoreProperty">x => x.TextScoreProp</param>
-        public Find<T, TProjection> SortByTextScore(Expression<Func<T, object>> scoreProperty)
+        public TSelf SortByTextScore(Expression<Func<T, object>>? scoreProperty)
         {
             switch (scoreProperty)
             {
@@ -264,37 +210,37 @@ public Find<T, TProjection> SortByTextScore(Expression<Func<T, object>> scorePro
         /// </summary>
         /// <param name="sortFunction">s => s.Ascending("Prop1").MetaTextScore("Prop2")</param>
         /// <returns></returns>
-        public Find<T, TProjection> Sort(Func<SortDefinitionBuilder<T>, SortDefinition<T>> sortFunction)
+        public TSelf Sort(Func<SortDefinitionBuilder<T>, SortDefinition<T>> sortFunction)
         {
-            sorts.Add(sortFunction(Builders<T>.Sort));
-            return this;
+            _sorts.Add(sortFunction(Builders<T>.Sort));
+            return This;
         }
 
         /// <summary>
         /// Specify how many entities to skip
         /// </summary>
         /// <param name="skipCount">The number to skip</param>
-        public Find<T, TProjection> Skip(int skipCount)
+        public TSelf Skip(int skipCount)
         {
-            options.Skip = skipCount;
-            return this;
+            _options.Skip = skipCount;
+            return This;
         }
 
         /// <summary>
         /// Specify how many entities to Take/Limit
         /// </summary>
         /// <param name="takeCount">The number to limit/take</param>
-        public Find<T, TProjection> Limit(int takeCount)
+        public TSelf Limit(int takeCount)
         {
-            options.Limit = takeCount;
-            return this;
+            _options.Limit = takeCount;
+            return This;
         }
 
         /// <summary>
         /// Specify how to project the results using a lambda expression
         /// </summary>
         /// <param name="expression">x => new Test { PropName = x.Prop }</param>
-        public Find<T, TProjection> Project(Expression<Func<T, TProjection>> expression)
+        public TSelf Project(Expression<Func<T, TProjection>> expression)
         {
             return Project(p => p.Expression(expression));
         }
@@ -303,22 +249,22 @@ public Find<T, TProjection> Project(Expression<Func<T, TProjection>> expression)
         /// Specify how to project the results using a projection expression
         /// </summary>
         /// <param name="projection">p => p.Include("Prop1").Exclude("Prop2")</param>
-        public Find<T, TProjection> Project(Func<ProjectionDefinitionBuilder<T>, ProjectionDefinition<T, TProjection>> projection)
+        public TSelf Project(Func<ProjectionDefinitionBuilder<T>, ProjectionDefinition<T, TProjection>> projection)
         {
-            options.Projection = projection(Builders<T>.Projection);
-            return this;
+            _options.Projection = projection(Builders<T>.Projection);
+            return This;
         }
 
         /// <summary>
         /// Specify how to project the results using an exclusion projection expression.
         /// </summary>
         /// <param name="exclusion">x => new { x.PropToExclude, x.AnotherPropToExclude }</param>
-        public Find<T, TProjection> ProjectExcluding(Expression<Func<T, object>> exclusion)
+        public TSelf ProjectExcluding(Expression<Func<T, object>> exclusion)
         {
             var props = (exclusion.Body as NewExpression)?.Arguments
                 .Select(a => a.ToString().Split('.')[1]);
 
-            if (!props.Any())
+            if (props == null || !props.Any())
                 throw new ArgumentException("Unable to get any properties from the exclusion expression!");
 
             var defs = new List<ProjectionDefinition<T>>(props.Count());
@@ -328,41 +274,133 @@ public Find<T, TProjection> ProjectExcluding(Expression<Func<T, object>> exclusi
                 defs.Add(Builders<T>.Projection.Exclude(prop));
             }
 
-            options.Projection = Builders<T>.Projection.Combine(defs);
+            _options.Projection = Builders<T>.Projection.Combine(defs);
 
-            return this;
+            return This;
         }
 
         /// <summary>
         /// Specify to automatically include all properties marked with [BsonRequired] attribute on the entity in the final projection.
         /// <para>HINT: this method should only be called after the .Project() method.</para>
         /// </summary>
-        public Find<T, TProjection> IncludeRequiredProps()
+        public TSelf IncludeRequiredProps()
         {
             if (typeof(T) != typeof(TProjection))
                 throw new InvalidOperationException("IncludeRequiredProps() cannot be used when projecting to a different type.");
 
-            options.Projection = Cache<T>.CombineWithRequiredProps(options.Projection);
-            return this;
+            _options.Projection = Cache<T>.Instance.CombineWithRequiredProps(_options.Projection);
+            return This;
         }
 
         /// <summary>
         /// Specify an option for this find command (use multiple times if needed)
         /// </summary>
         /// <param name="option">x => x.OptionName = OptionValue</param>
-        public Find<T, TProjection> Option(Action<FindOptions<T, TProjection>> option)
+        public TSelf Option(Action<FindOptions<T, TProjection>> option)
         {
-            option(options);
-            return this;
+            option(_options);
+            return This;
         }
 
         /// <summary>
         /// Specify that this operation should ignore any global filters
         /// </summary>
-        public Find<T, TProjection> IgnoreGlobalFilters()
+        public TSelf IgnoreGlobalFilters()
         {
-            ignoreGlobalFilters = true;
-            return this;
+            _ignoreGlobalFilters = true;
+            return This;
+        }
+
+
+        private void AddTxtScoreToProjection(string propName)
+        {
+            if (_options.Projection == null) _options.Projection = "{}";
+
+            _options.Projection =
+                _options.Projection
+                .Render(BsonSerializer.SerializerRegistry.GetSerializer<T>(), BsonSerializer.SerializerRegistry)
+                .Document.Add(propName, new BsonDocument { { "$meta", "textScore" } });
+        }
+
+    }
+
+    /// <summary>
+    /// Represents a MongoDB Find command.
+    /// <para>TIP: Specify your criteria using .Match() .Sort() .Skip() .Take() .Project() .Option() methods and finally call .Execute()</para>
+    /// <para>Note: For building queries, use the DB.Fluent* interfaces</para>
+    /// </summary>
+    /// <typeparam name="T">Any class that implements IEntity</typeparam>
+    public class Find<T> : Find<T, T> where T : IEntity
+    {
+        internal Find(Dictionary<Type, (object filterDef, bool prepend)> globalFilters, DBContext context, IMongoCollection<T> collection)
+            : base(globalFilters, context, collection) { }
+    }
+
+
+    /// <summary>
+    /// Represents a MongoDB Find command with the ability to project to a different result type.
+    /// <para>TIP: Specify your criteria using .Match() .Sort() .Skip() .Take() .Project() .Option() methods and finally call .Execute()</para>
+    /// </summary>
+    /// <typeparam name="T">Any class that implements IEntity</typeparam>
+    /// <typeparam name="TProjection">The type you'd like to project the results to.</typeparam>
+    public class Find<T, TProjection> : FindBase<T, TProjection, Find<T, TProjection>> where T : IEntity
+    {
+        /// <summary>
+        /// copy constructor
+        /// </summary>
+        /// <param name="other"></param>
+        /// <param name="context"></param>
+        /// <param name="collection"></param>
+        internal Find(FindBase<T, TProjection, Find<T, TProjection>> other, DBContext context, IMongoCollection<T> collection) : base(other)
+        {
+            Context = context;
+            Collection = collection;
+        }
+        internal Find(Dictionary<Type, (object filterDef, bool prepend)> globalFilters, DBContext context, IMongoCollection<T> collection) : base(globalFilters)
+        {
+            Context = context;
+            Collection = collection;
+        }
+        public DBContext Context { get; private set; }
+        public IMongoCollection<T> Collection { get; private set; }
+
+        public IClientSessionHandle? Session => Context.Session;
+
+
+        /// <summary>
+        /// Find a single IEntity by ID
+        /// </summary>
+        /// <param name="ID">The unique ID of an IEntity</param>
+        /// <param name="cancellation">An optional cancellation token</param>
+        /// <returns>A single entity or null if not found</returns>
+        public Task<TProjection> OneAsync(string ID, CancellationToken cancellation = default)
+        {
+            Match(ID);
+            return ExecuteSingleAsync(cancellation);
+        }
+
+        /// <summary>
+        /// Find entities by supplying a lambda expression
+        /// </summary>
+        /// <param name="expression">x => x.Property == Value</param>
+        /// <param name="cancellation">An optional cancellation token</param>
+        /// <returns>A list of Entities</returns>
+        public Task<List<TProjection>> ManyAsync(Expression<Func<T, bool>> expression, CancellationToken cancellation = default)
+        {
+            Match(expression);
+            return ExecuteAsync(cancellation);
+        }
+
+        /// <summary>
+        /// Find entities by supplying a filter expression
+        /// </summary>
+        /// <param name="filter">f => f.Eq(x => x.Prop, Value) &amp; f.Gt(x => x.Prop, Value)</param>
+        /// <param name="cancellation">An optional cancellation token</param>
+        /// <returns>A list of Entities</returns>
+        public Task<List<TProjection>> ManyAsync(Func<FilterDefinitionBuilder<T>, FilterDefinition<T>> filter, CancellationToken cancellation = default)
+        {
+            Match(filter);
+            return ExecuteAsync(cancellation);
         }
 
         /// <summary>
@@ -426,27 +464,16 @@ public async Task<bool> ExecuteAnyAsync(CancellationToken cancellation = default
         /// <param name="cancellation">An optional cancellation token</param>
         public Task<IAsyncCursor<TProjection>> ExecuteCursorAsync(CancellationToken cancellation = default)
         {
-            if (sorts.Count > 0)
-                options.Sort = Builders<T>.Sort.Combine(sorts);
+            if (_sorts.Count > 0)
+                _options.Sort = Builders<T>.Sort.Combine(_sorts);
 
-            var mergedFilter = Logic.MergeWithGlobalFilter(ignoreGlobalFilters, globalFilters, filter);
+            var mergedFilter = Logic.MergeWithGlobalFilter(_ignoreGlobalFilters, _globalFilters, _filter);
 
-            return session == null
-                   ? DB.Collection<T>(tenantPrefix).FindAsync(mergedFilter, options, cancellation)
-                   : DB.Collection<T>(tenantPrefix).FindAsync(session, mergedFilter, options, cancellation);
-        }
-
-        private void AddTxtScoreToProjection(string propName)
-        {
-            if (options.Projection == null) options.Projection = "{}";
-
-            options.Projection =
-                options.Projection
-                .Render(BsonSerializer.SerializerRegistry.GetSerializer<T>(), BsonSerializer.SerializerRegistry)
-                .Document.Add(propName, new BsonDocument { { "$meta", "textScore" } });
+            return Session == null ?
+                Collection.FindAsync(mergedFilter, _options, cancellation) :
+                Collection.FindAsync(Context.Session, mergedFilter, _options, cancellation);
         }
     }
-
     public enum Order
     {
         Ascending,

From 62362a142df0b38026f471d875fffd64d1211048 Mon Sep 17 00:00:00 2001
From: Ahmed Fwela <ahmednfwela@bdaya-dev.com>
Date: Fri, 5 Nov 2021 16:40:03 +0200
Subject: [PATCH 07/26] WIP missing Update, UpdateAndGet from builders

---
 MongoDB.Entities/Builders/Distinct.cs         | 191 +++--------
 MongoDB.Entities/Builders/FilterQueryBase.cs  | 169 ++++++++++
 MongoDB.Entities/Builders/Find.cs             | 280 +++-------------
 .../Builders/ICollectionRelated.cs            |  21 ++
 MongoDB.Entities/Builders/Index.cs            |  33 +-
 MongoDB.Entities/Builders/PagedSearch.cs      | 316 +++++-------------
 MongoDB.Entities/Builders/Replace.cs          | 221 +++---------
 .../Builders/SortFilterQueryBase.cs           |  49 +++
 MongoDB.Entities/Builders/Update.cs           | 279 +++++-----------
 MongoDB.Entities/Builders/UpdateAndGet.cs     |   9 +-
 MongoDB.Entities/Core/Cache.cs                |   8 +-
 MongoDB.Entities/DBContext/DBContext.cs       |   4 +-
 MongoDB.Entities/Extensions/Entity.cs         |  16 -
 MongoDB.Entities/MongoDB.Entities.csproj      |  76 ++---
 MongoDB.Entities/Relationships/Many.cs        |   2 +
 15 files changed, 623 insertions(+), 1051 deletions(-)
 create mode 100644 MongoDB.Entities/Builders/FilterQueryBase.cs
 create mode 100644 MongoDB.Entities/Builders/ICollectionRelated.cs
 create mode 100644 MongoDB.Entities/Builders/SortFilterQueryBase.cs

diff --git a/MongoDB.Entities/Builders/Distinct.cs b/MongoDB.Entities/Builders/Distinct.cs
index 8fb4e563c..9c134bc79 100644
--- a/MongoDB.Entities/Builders/Distinct.cs
+++ b/MongoDB.Entities/Builders/Distinct.cs
@@ -7,170 +7,81 @@
 
 namespace MongoDB.Entities
 {
-    /// <summary>
-    /// Represents a MongoDB Distinct command where you can get back distinct values for a given property of a given Entity.
-    /// </summary>
-    /// <typeparam name="T">Any Entity that implements IEntity interface</typeparam>
-    /// <typeparam name="TProperty">The type of the property of the entity you'd like to get unique values for</typeparam>
-    public class Distinct<T, TProperty> where T : IEntity
+    public class DistinctBase<T, TProperty, TSelf> : FilterQueryBase<T, TSelf> where T : IEntity where TSelf : DistinctBase<T, TProperty, TSelf>
     {
-        private FieldDefinition<T, TProperty> field;
-        private FilterDefinition<T> filter = Builders<T>.Filter.Empty;
-        private readonly DistinctOptions options = new();
-        private readonly IClientSessionHandle session;
-        private readonly Dictionary<Type, (object filterDef, bool prepend)> globalFilters;
-        private bool ignoreGlobalFilters;
-        private readonly string tenantPrefix;
-
-        internal Distinct(
-            IClientSessionHandle session,
-            Dictionary<Type, (object filterDef, bool prepend)> globalFilters, string tenantPrefix)
-        {
-            this.session = session;
-            this.globalFilters = globalFilters;
-            this.tenantPrefix = tenantPrefix;
-        }
-
-        /// <summary>
-        /// Specify the property you want to get the unique values for (as a string path)
-        /// </summary>
-        /// <param name="property">ex: "Address.Street"</param>
-        public Distinct<T, TProperty> Property(string property)
-        {
-            field = property;
-            return this;
-        }
+        internal DistinctOptions _options = new();
+        internal FieldDefinition<T, TProperty>? _field;
 
-        /// <summary>
-        /// Specify the property you want to get the unique values for (as a member expression)
-        /// </summary>
-        /// <param name="property">x => x.Address.Street</param>
-        public Distinct<T, TProperty> Property(Expression<Func<T, object>> property)
-        {
-            field = property.FullPath();
-            return this;
-        }
-
-        /// <summary>
-        /// Specify the matching criteria with a filter expression
-        /// </summary>
-        /// <param name="filter">f => f.Eq(x => x.Prop, Value) &amp; f.Gt(x => x.Prop, Value)</param>
-        public Distinct<T, TProperty> Match(Func<FilterDefinitionBuilder<T>, FilterDefinition<T>> filter)
+        internal DistinctBase(DistinctBase<T, TProperty, TSelf> other) : base(other)
         {
-            this.filter &= filter(Builders<T>.Filter);
-            return this;
+            _options = other._options;
+            _field = other._field;
         }
-
-        /// <summary>
-        /// Specify the matching criteria with a lambda expression
-        /// </summary>
-        /// <param name="expression">x => x.Property == Value</param>
-        public Distinct<T, TProperty> Match(Expression<Func<T, bool>> expression)
+        internal DistinctBase(Dictionary<Type, (object filterDef, bool prepend)> globalFilters) : base(globalFilters)
         {
-            return Match(f => f.Where(expression));
+            _globalFilters = globalFilters;
         }
 
-        /// <summary>
-        /// Specify the matching criteria with a template
-        /// </summary>
-        /// <param name="template">A Template with a find query</param>
-        public Distinct<T, TProperty> Match(Template template)
-        {
-            filter &= template.RenderToString();
-            return this;
-        }
 
-        /// <summary>
-        /// Specify a search term to find results from the text index of this particular collection.
-        /// <para>TIP: Make sure to define a text index with DB.Index&lt;T&gt;() before searching</para>
-        /// </summary>
-        /// <param name="searchType">The type of text matching to do</param>
-        /// <param name="searchTerm">The search term</param>
-        /// <param name="caseSensitive">Case sensitivity of the search (optional)</param>
-        /// <param name="diacriticSensitive">Diacritic sensitivity of the search (optional)</param>
-        /// <param name="language">The language for the search (optional)</param>
-        public Distinct<T, TProperty> Match(Search searchType, string searchTerm, bool caseSensitive = false, bool diacriticSensitive = false, string language = null)
-        {
-            if (searchType == Search.Fuzzy)
-            {
-                searchTerm = searchTerm.ToDoubleMetaphoneHash();
-                caseSensitive = false;
-                diacriticSensitive = false;
-                language = null;
-            }
+        private TSelf This => (TSelf)this;
 
-            return Match(
-                f => f.Text(
-                    searchTerm,
-                    new TextSearchOptions
-                    {
-                        CaseSensitive = caseSensitive,
-                        DiacriticSensitive = diacriticSensitive,
-                        Language = language
-                    }));
-        }
 
         /// <summary>
-        /// Specify criteria for matching entities based on GeoSpatial data (longitude &amp; latitude)
-        /// <para>TIP: Make sure to define a Geo2DSphere index with DB.Index&lt;T&gt;() before searching</para>
-        /// <para>Note: DB.FluentGeoNear() supports more advanced options</para>
+        /// Specify an option for this find command (use multiple times if needed)
         /// </summary>
-        /// <param name="coordinatesProperty">The property where 2DCoordinates are stored</param>
-        /// <param name="nearCoordinates">The search point</param>
-        /// <param name="maxDistance">Maximum distance in meters from the search point</param>
-        /// <param name="minDistance">Minimum distance in meters from the search point</param>
-        public Distinct<T, TProperty> Match(Expression<Func<T, object>> coordinatesProperty, Coordinates2D nearCoordinates, double? maxDistance = null, double? minDistance = null)
+        /// <param name="option">x => x.OptionName = OptionValue</param>
+        public TSelf Option(Action<DistinctOptions> option)
         {
-            return Match(f => f.Near(coordinatesProperty, nearCoordinates.ToGeoJsonPoint(), maxDistance, minDistance));
+            option(_options);
+            return This;
         }
 
         /// <summary>
-        /// Specify the matching criteria with a JSON string
+        /// Specify the property you want to get the unique values for (as a string path)
         /// </summary>
-        /// <param name="jsonString">{ Title : 'The Power Of Now' }</param>
-        public Distinct<T, TProperty> MatchString(string jsonString)
+        /// <param name="property">ex: "Address.Street"</param>
+        public TSelf Property(string property)
         {
-            filter &= jsonString;
-            return this;
+            _field = property;
+            return This;
         }
 
         /// <summary>
-        /// Specify the matching criteria with an aggregation expression (i.e. $expr)
+        /// Specify the property you want to get the unique values for (as a member expression)
         /// </summary>
-        /// <param name="expression">{ $gt: ['$Property1', '$Property2'] }</param>
-        public Distinct<T, TProperty> MatchExpression(string expression)
+        /// <param name="property">x => x.Address.Street</param>
+        public TSelf Property(Expression<Func<T, object>> property)
         {
-            filter &= "{$expr:" + expression + "}";
-            return this;
+            _field = property.FullPath();
+            return This;
         }
+    }
 
-        /// <summary>
-        /// Specify the matching criteria with a Template
-        /// </summary>
-        /// <param name="template">A Template object</param>
-        public Distinct<T, TProperty> MatchExpression(Template template)
-        {
-            filter &= "{$expr:" + template.RenderToString() + "}";
-            return this;
-        }
+    /// <summary>
+    /// Represents a MongoDB Distinct command where you can get back distinct values for a given property of a given Entity.
+    /// </summary>
+    /// <typeparam name="T">Any Entity that implements IEntity interface</typeparam>
+    /// <typeparam name="TProperty">The type of the property of the entity you'd like to get unique values for</typeparam>
+    public class Distinct<T, TProperty> : DistinctBase<T, TProperty, Distinct<T, TProperty>>, ICollectionRelated<T> where T : IEntity
+    {
+        public DBContext Context { get; }
+        public IMongoCollection<T> Collection { get; }
 
-        /// <summary>
-        /// Specify an option for this find command (use multiple times if needed)
-        /// </summary>
-        /// <param name="option">x => x.OptionName = OptionValue</param>
-        public Distinct<T, TProperty> Option(Action<DistinctOptions> option)
+        internal Distinct(
+            DBContext context,
+            IMongoCollection<T> collection,
+            DistinctBase<T, TProperty, Distinct<T, TProperty>> other) : base(other)
         {
-            option(options);
-            return this;
+            Context = context;
+            Collection = collection;
         }
-
-        /// <summary>
-        /// Specify that this operation should ignore any global filters
-        /// </summary>
-        public Distinct<T, TProperty> IgnoreGlobalFilters()
+        internal Distinct(
+            DBContext context,
+            IMongoCollection<T> collection,
+            Dictionary<Type, (object filterDef, bool prepend)> globalFilters) : base(globalFilters: globalFilters)
         {
-            ignoreGlobalFilters = true;
-            return this;
+            Context = context;
+            Collection = collection;
         }
 
         /// <summary>
@@ -179,14 +90,14 @@ public Distinct<T, TProperty> IgnoreGlobalFilters()
         /// <param name="cancellation">An optional cancellation token</param>
         public Task<IAsyncCursor<TProperty>> ExecuteCursorAsync(CancellationToken cancellation = default)
         {
-            if (field == null)
+            if (_field == null)
                 throw new InvalidOperationException("Please use the .Property() method to specify the field to use for obtaining unique values for!");
 
-            var mergedFilter = Logic.MergeWithGlobalFilter(ignoreGlobalFilters, globalFilters, filter);
+            var mergedFilter = Logic.MergeWithGlobalFilter(_ignoreGlobalFilters, _globalFilters, _filter);
 
-            return session == null
-                   ? DB.Collection<T>(tenantPrefix).DistinctAsync(field, mergedFilter, options, cancellation)
-                   : DB.Collection<T>(tenantPrefix).DistinctAsync(session, field, mergedFilter, options, cancellation);
+            return Context.Session is IClientSessionHandle session
+                   ? Collection.DistinctAsync(session, _field, mergedFilter, _options, cancellation)
+                   : Collection.DistinctAsync(_field, mergedFilter, _options, cancellation);
         }
 
         /// <summary>
diff --git a/MongoDB.Entities/Builders/FilterQueryBase.cs b/MongoDB.Entities/Builders/FilterQueryBase.cs
new file mode 100644
index 000000000..6b82e93c9
--- /dev/null
+++ b/MongoDB.Entities/Builders/FilterQueryBase.cs
@@ -0,0 +1,169 @@
+using MongoDB.Driver;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+namespace MongoDB.Entities
+{
+    public class FilterQueryBase<T, TSelf> where T : IEntity where TSelf : FilterQueryBase<T, TSelf>
+    {
+        internal FilterDefinition<T> _filter = Builders<T>.Filter.Empty;
+        internal Dictionary<Type, (object filterDef, bool prepend)> _globalFilters;
+        internal bool _ignoreGlobalFilters;
+
+        internal FilterQueryBase(FilterQueryBase<T, TSelf> other) : this(globalFilters: other._globalFilters)
+        {
+            _filter = other._filter;
+            _ignoreGlobalFilters = other._ignoreGlobalFilters;
+        }
+        internal FilterQueryBase(Dictionary<Type, (object filterDef, bool prepend)> globalFilters)
+        {
+            _globalFilters = globalFilters;
+        }
+
+        protected FilterDefinition<T> MergedFilter => Logic.MergeWithGlobalFilter(_ignoreGlobalFilters, _globalFilters, _filter);
+        private TSelf This => (TSelf)this;
+
+
+        /// <summary>
+        /// Specify that this operation should ignore any global filters
+        /// </summary>
+        public TSelf IgnoreGlobalFilters()
+        {
+            _ignoreGlobalFilters = true;
+            return This;
+        }
+
+
+
+        /// <summary>
+        /// Specify an IEntity ID as the matching criteria
+        /// </summary>
+        /// <param name="ID">A unique IEntity ID</param>
+        public TSelf Match(string ID)
+        {
+            return Match(f => f.Eq(t => t.ID, ID));
+        }
+
+        /// <summary>
+        /// Specify the matching criteria with a lambda expression
+        /// </summary>
+        /// <param name="expression">x => x.Property == Value</param>
+        public TSelf Match(Expression<Func<T, bool>> expression)
+        {
+            return Match(f => f.Where(expression));
+        }
+
+        /// <summary>
+        /// Specify the matching criteria with a filter expression
+        /// </summary>
+        /// <param name="filter">f => f.Eq(x => x.Prop, Value) &amp; f.Gt(x => x.Prop, Value)</param>
+        public TSelf Match(Func<FilterDefinitionBuilder<T>, FilterDefinition<T>> filter)
+        {
+            _filter &= filter(Builders<T>.Filter);
+            return This;
+        }
+
+        /// <summary>
+        /// Specify the matching criteria with a filter definition
+        /// </summary>
+        /// <param name="filterDefinition">A filter definition</param>
+        public TSelf Match(FilterDefinition<T> filterDefinition)
+        {
+            _filter &= filterDefinition;
+            return This;
+        }
+
+        /// <summary>
+        /// Specify the matching criteria with a template
+        /// </summary>
+        /// <param name="template">A Template with a find query</param>
+        public TSelf Match(Template template)
+        {
+            _filter &= template.RenderToString();
+            return This;
+        }
+
+        /// <summary>
+        /// Specify a search term to find results from the text index of this particular collection.
+        /// <para>TIP: Make sure to define a text index with DB.Index&lt;T&gt;() before searching</para>
+        /// </summary>
+        /// <param name="searchType">The type of text matching to do</param>
+        /// <param name="searchTerm">The search term</param>
+        /// <param name="caseSensitive">Case sensitivity of the search (optional)</param>
+        /// <param name="diacriticSensitive">Diacritic sensitivity of the search (optional)</param>
+        /// <param name="language">The language for the search (optional)</param>
+        public TSelf Match(Search searchType, string searchTerm, bool caseSensitive = false, bool diacriticSensitive = false, string? language = null)
+        {
+            if (searchType == Search.Fuzzy)
+            {
+                searchTerm = searchTerm.ToDoubleMetaphoneHash();
+                caseSensitive = false;
+                diacriticSensitive = false;
+                language = null;
+            }
+
+            return Match(
+                f => f.Text(
+                    searchTerm,
+                    new TextSearchOptions
+                    {
+                        CaseSensitive = caseSensitive,
+                        DiacriticSensitive = diacriticSensitive,
+                        Language = language
+                    }));
+        }
+
+        /// <summary>
+        /// Specify criteria for matching entities based on GeoSpatial data (longitude &amp; latitude)
+        /// <para>TIP: Make sure to define a Geo2DSphere index with DB.Index&lt;T&gt;() before searching</para>
+        /// <para>Note: DB.FluentGeoNear() supports more advanced options</para>
+        /// </summary>
+        /// <param name="coordinatesProperty">The property where 2DCoordinates are stored</param>
+        /// <param name="nearCoordinates">The search point</param>
+        /// <param name="maxDistance">Maximum distance in meters from the search point</param>
+        /// <param name="minDistance">Minimum distance in meters from the search point</param>
+        public TSelf Match(Expression<Func<T, object>> coordinatesProperty, Coordinates2D nearCoordinates, double? maxDistance = null, double? minDistance = null)
+        {
+            return Match(f => f.Near(coordinatesProperty, nearCoordinates.ToGeoJsonPoint(), maxDistance, minDistance));
+        }
+
+        /// <summary>
+        /// Specify the matching criteria with an aggregation expression (i.e. $expr)
+        /// </summary>
+        /// <param name="expression">{ $gt: ['$Property1', '$Property2'] }</param>
+        public TSelf MatchExpression(string expression)
+        {
+            _filter &= "{$expr:" + expression + "}";
+            return This;
+        }
+
+        /// <summary>
+        /// Specify the matching criteria with a Template
+        /// </summary>
+        /// <param name="template">A Template object</param>
+        public TSelf MatchExpression(Template template)
+        {
+            return MatchExpression(template.RenderToString());
+        }
+
+        /// <summary>
+        /// Specify an IEntity ID as the matching criteria
+        /// </summary>
+        /// <param name="ID">A unique IEntity ID</param>
+        public TSelf MatchID(string ID)
+        {
+            return Match(f => f.Eq(t => t.ID, ID));
+        }
+
+        /// <summary>
+        /// Specify the matching criteria with a JSON string
+        /// </summary>
+        /// <param name="jsonString">{ Title : 'The Power Of Now' }</param>
+        public TSelf MatchString(string jsonString)
+        {
+            _filter &= jsonString;
+            return This;
+        }
+    }
+}
diff --git a/MongoDB.Entities/Builders/Find.cs b/MongoDB.Entities/Builders/Find.cs
index 946972f64..13ccc3faf 100644
--- a/MongoDB.Entities/Builders/Find.cs
+++ b/MongoDB.Entities/Builders/Find.cs
@@ -10,212 +10,21 @@
 #nullable enable
 namespace MongoDB.Entities
 {
-    public class FindBase<T, TProjection, TSelf> where T : IEntity where TSelf : FindBase<T, TProjection, TSelf>
+    public class FindBase<T, TProjection, TSelf> : SortFilterQueryBase<T, TSelf> where T : IEntity where TSelf : FindBase<T, TProjection, TSelf>
     {
-        internal FilterDefinition<T> _filter = Builders<T>.Filter.Empty;
-        internal List<SortDefinition<T>> _sorts = new();
         internal FindOptions<T, TProjection> _options = new();
-        internal Dictionary<Type, (object filterDef, bool prepend)> _globalFilters;
-        internal bool _ignoreGlobalFilters;
 
-        internal FindBase(FindBase<T, TProjection, TSelf> other) : this(globalFilters: other._globalFilters)
+        internal FindBase(FindBase<T, TProjection, TSelf> other) : base(other)
         {
-            _filter = other._filter;
             _options = other._options;
-            _sorts = other._sorts;
-            _ignoreGlobalFilters = other._ignoreGlobalFilters;
         }
-        internal FindBase(Dictionary<Type, (object filterDef, bool prepend)> globalFilters)
+        internal FindBase(Dictionary<Type, (object filterDef, bool prepend)> globalFilters) : base(globalFilters: globalFilters)
         {
             _globalFilters = globalFilters;
         }
 
         private TSelf This => (TSelf)this;
 
-        /// <summary>
-        /// Specify an IEntity ID as the matching criteria
-        /// </summary>
-        /// <param name="ID">A unique IEntity ID</param>
-        public TSelf MatchID(string ID)
-        {
-            return Match(f => f.Eq(t => t.ID, ID));
-        }
-
-        /// <summary>
-        /// Specify an IEntity ID as the matching criteria
-        /// </summary>
-        /// <param name="ID">A unique IEntity ID</param>
-        public TSelf Match(string ID)
-        {
-            return Match(f => f.Eq(t => t.ID, ID));
-        }
-
-        /// <summary>
-        /// Specify the matching criteria with a lambda expression
-        /// </summary>
-        /// <param name="expression">x => x.Property == Value</param>
-        public TSelf Match(Expression<Func<T, bool>> expression)
-        {
-            return Match(f => f.Where(expression));
-        }
-
-        /// <summary>
-        /// Specify the matching criteria with a filter expression
-        /// </summary>
-        /// <param name="filter">f => f.Eq(x => x.Prop, Value) &amp; f.Gt(x => x.Prop, Value)</param>
-        public TSelf Match(Func<FilterDefinitionBuilder<T>, FilterDefinition<T>> filter)
-        {
-            _filter &= filter(Builders<T>.Filter);
-            return This;
-        }
-
-        /// <summary>
-        /// Specify the matching criteria with a filter definition
-        /// </summary>
-        /// <param name="filterDefinition">A filter definition</param>
-        public TSelf Match(FilterDefinition<T> filterDefinition)
-        {
-            _filter &= filterDefinition;
-            return This;
-        }
-
-        /// <summary>
-        /// Specify the matching criteria with a template
-        /// </summary>
-        /// <param name="template">A Template with a find query</param>
-        public TSelf Match(Template template)
-        {
-            _filter &= template.RenderToString();
-            return This;
-        }
-
-        /// <summary>
-        /// Specify a search term to find results from the text index of this particular collection.
-        /// <para>TIP: Make sure to define a text index with DB.Index&lt;T&gt;() before searching</para>
-        /// </summary>
-        /// <param name="searchType">The type of text matching to do</param>
-        /// <param name="searchTerm">The search term</param>
-        /// <param name="caseSensitive">Case sensitivity of the search (optional)</param>
-        /// <param name="diacriticSensitive">Diacritic sensitivity of the search (optional)</param>
-        /// <param name="language">The language for the search (optional)</param>
-        public TSelf Match(Search searchType, string searchTerm, bool caseSensitive = false, bool diacriticSensitive = false, string? language = null)
-        {
-            if (searchType == Search.Fuzzy)
-            {
-                searchTerm = searchTerm.ToDoubleMetaphoneHash();
-                caseSensitive = false;
-                diacriticSensitive = false;
-                language = null;
-            }
-
-            return Match(
-                f => f.Text(
-                    searchTerm,
-                    new TextSearchOptions
-                    {
-                        CaseSensitive = caseSensitive,
-                        DiacriticSensitive = diacriticSensitive,
-                        Language = language
-                    }));
-        }
-
-        /// <summary>
-        /// Specify criteria for matching entities based on GeoSpatial data (longitude &amp; latitude)
-        /// <para>TIP: Make sure to define a Geo2DSphere index with DB.Index&lt;T&gt;() before searching</para>
-        /// <para>Note: DB.FluentGeoNear() supports more advanced options</para>
-        /// </summary>
-        /// <param name="coordinatesProperty">The property where 2DCoordinates are stored</param>
-        /// <param name="nearCoordinates">The search point</param>
-        /// <param name="maxDistance">Maximum distance in meters from the search point</param>
-        /// <param name="minDistance">Minimum distance in meters from the search point</param>
-        public TSelf Match(Expression<Func<T, object>> coordinatesProperty, Coordinates2D nearCoordinates, double? maxDistance = null, double? minDistance = null)
-        {
-            return Match(f => f.Near(coordinatesProperty, nearCoordinates.ToGeoJsonPoint(), maxDistance, minDistance));
-        }
-
-        /// <summary>
-        /// Specify the matching criteria with a JSON string
-        /// </summary>
-        /// <param name="jsonString">{ Title : 'The Power Of Now' }</param>
-        public TSelf MatchString(string jsonString)
-        {
-            _filter &= jsonString;
-            return This;
-        }
-
-        /// <summary>
-        /// Specify the matching criteria with an aggregation expression (i.e. $expr)
-        /// </summary>
-        /// <param name="expression">{ $gt: ['$Property1', '$Property2'] }</param>
-        public TSelf MatchExpression(string expression)
-        {
-            _filter &= "{$expr:" + expression + "}";
-            return This;
-        }
-
-        /// <summary>
-        /// Specify the matching criteria with a Template
-        /// </summary>
-        /// <param name="template">A Template object</param>
-        public TSelf MatchExpression(Template template)
-        {
-            return MatchExpression(template.RenderToString());
-        }
-
-        /// <summary>
-        /// Specify which property and order to use for sorting (use multiple times if needed)
-        /// </summary>
-        /// <param name="propertyToSortBy">x => x.Prop</param>
-        /// <param name="sortOrder">The sort order</param>
-        public TSelf Sort(Expression<Func<T, object>> propertyToSortBy, Order sortOrder)
-        {
-            return sortOrder switch
-            {
-                Order.Ascending => Sort(s => s.Ascending(propertyToSortBy)),
-                Order.Descending => Sort(s => s.Descending(propertyToSortBy)),
-                _ => This,
-            };
-        }
-
-        /// <summary>
-        /// Sort the results of a text search by the MetaTextScore
-        /// <para>TIP: Use this method after .Project() if you need to do a projection also</para>
-        /// </summary>
-        public TSelf SortByTextScore()
-        {
-            return SortByTextScore(null);
-        }
-
-        /// <summary>
-        /// Sort the results of a text search by the MetaTextScore and get back the score as well
-        /// <para>TIP: Use this method after .Project() if you need to do a projection also</para>
-        /// </summary>
-        /// <param name="scoreProperty">x => x.TextScoreProp</param>
-        public TSelf SortByTextScore(Expression<Func<T, object>>? scoreProperty)
-        {
-            switch (scoreProperty)
-            {
-                case null:
-                    AddTxtScoreToProjection("_Text_Match_Score_");
-                    return Sort(s => s.MetaTextScore("_Text_Match_Score_"));
-
-                default:
-                    AddTxtScoreToProjection(Prop.Path(scoreProperty));
-                    return Sort(s => s.MetaTextScore(Prop.Path(scoreProperty)));
-            }
-        }
-
-        /// <summary>
-        /// Specify how to sort using a sort expression
-        /// </summary>
-        /// <param name="sortFunction">s => s.Ascending("Prop1").MetaTextScore("Prop2")</param>
-        /// <returns></returns>
-        public TSelf Sort(Func<SortDefinitionBuilder<T>, SortDefinition<T>> sortFunction)
-        {
-            _sorts.Add(sortFunction(Builders<T>.Sort));
-            return This;
-        }
-
         /// <summary>
         /// Specify how many entities to skip
         /// </summary>
@@ -255,6 +64,19 @@ public TSelf Project(Func<ProjectionDefinitionBuilder<T>, ProjectionDefinition<T
             return This;
         }
 
+        /// <summary>
+        /// Specify to automatically include all properties marked with [BsonRequired] attribute on the entity in the final projection.
+        /// <para>HINT: this method should only be called after the .Project() method.</para>
+        /// </summary>
+        public TSelf IncludeRequiredProps()
+        {
+            if (typeof(T) != typeof(TProjection))
+                throw new InvalidOperationException("IncludeRequiredProps() cannot be used when projecting to a different type.");
+
+            _options.Projection = Cache<T>.Instance.CombineWithRequiredProps(_options.Projection);
+            return This;
+        }
+
         /// <summary>
         /// Specify how to project the results using an exclusion projection expression.
         /// </summary>
@@ -279,19 +101,6 @@ public TSelf ProjectExcluding(Expression<Func<T, object>> exclusion)
             return This;
         }
 
-        /// <summary>
-        /// Specify to automatically include all properties marked with [BsonRequired] attribute on the entity in the final projection.
-        /// <para>HINT: this method should only be called after the .Project() method.</para>
-        /// </summary>
-        public TSelf IncludeRequiredProps()
-        {
-            if (typeof(T) != typeof(TProjection))
-                throw new InvalidOperationException("IncludeRequiredProps() cannot be used when projecting to a different type.");
-
-            _options.Projection = Cache<T>.Instance.CombineWithRequiredProps(_options.Projection);
-            return This;
-        }
-
         /// <summary>
         /// Specify an option for this find command (use multiple times if needed)
         /// </summary>
@@ -302,16 +111,6 @@ public TSelf Option(Action<FindOptions<T, TProjection>> option)
             return This;
         }
 
-        /// <summary>
-        /// Specify that this operation should ignore any global filters
-        /// </summary>
-        public TSelf IgnoreGlobalFilters()
-        {
-            _ignoreGlobalFilters = true;
-            return This;
-        }
-
-
         private void AddTxtScoreToProjection(string propName)
         {
             if (_options.Projection == null) _options.Projection = "{}";
@@ -322,6 +121,33 @@ private void AddTxtScoreToProjection(string propName)
                 .Document.Add(propName, new BsonDocument { { "$meta", "textScore" } });
         }
 
+        /// <summary>
+        /// Sort the results of a text search by the MetaTextScore
+        /// <para>TIP: Use this method after .Project() if you need to do a projection also</para>
+        /// </summary>
+        public TSelf SortByTextScore()
+        {
+            return SortByTextScore(null);
+        }
+
+        /// <summary>
+        /// Sort the results of a text search by the MetaTextScore and get back the score as well
+        /// <para>TIP: Use this method after .Project() if you need to do a projection also</para>
+        /// </summary>
+        /// <param name="scoreProperty">x => x.TextScoreProp</param>
+        public TSelf SortByTextScore(Expression<Func<T, object>>? scoreProperty)
+        {
+            switch (scoreProperty)
+            {
+                case null:
+                    AddTxtScoreToProjection("_Text_Match_Score_");
+                    return Sort(s => s.MetaTextScore("_Text_Match_Score_"));
+
+                default:
+                    AddTxtScoreToProjection(Prop.Path(scoreProperty));
+                    return Sort(s => s.MetaTextScore(Prop.Path(scoreProperty)));
+            }
+        }
     }
 
     /// <summary>
@@ -332,8 +158,11 @@ private void AddTxtScoreToProjection(string propName)
     /// <typeparam name="T">Any class that implements IEntity</typeparam>
     public class Find<T> : Find<T, T> where T : IEntity
     {
-        internal Find(Dictionary<Type, (object filterDef, bool prepend)> globalFilters, DBContext context, IMongoCollection<T> collection)
-            : base(globalFilters, context, collection) { }
+        internal Find(DBContext context, IMongoCollection<T> collection, Dictionary<Type, (object filterDef, bool prepend)> globalFilters)
+            : base(context, collection, globalFilters) { }
+
+        internal Find(DBContext context, IMongoCollection<T> collection, FindBase<T, T, Find<T, T>> baseQuery)
+            : base(context, collection, baseQuery) { }
     }
 
 
@@ -343,7 +172,7 @@ internal Find(Dictionary<Type, (object filterDef, bool prepend)> globalFilters,
     /// </summary>
     /// <typeparam name="T">Any class that implements IEntity</typeparam>
     /// <typeparam name="TProjection">The type you'd like to project the results to.</typeparam>
-    public class Find<T, TProjection> : FindBase<T, TProjection, Find<T, TProjection>> where T : IEntity
+    public class Find<T, TProjection> : FindBase<T, TProjection, Find<T, TProjection>>, ICollectionRelated<T> where T : IEntity
     {
         /// <summary>
         /// copy constructor
@@ -351,20 +180,20 @@ public class Find<T, TProjection> : FindBase<T, TProjection, Find<T, TProjection
         /// <param name="other"></param>
         /// <param name="context"></param>
         /// <param name="collection"></param>
-        internal Find(FindBase<T, TProjection, Find<T, TProjection>> other, DBContext context, IMongoCollection<T> collection) : base(other)
+        internal Find(DBContext context, IMongoCollection<T> collection, FindBase<T, TProjection, Find<T, TProjection>> other) : base(other)
         {
             Context = context;
             Collection = collection;
         }
-        internal Find(Dictionary<Type, (object filterDef, bool prepend)> globalFilters, DBContext context, IMongoCollection<T> collection) : base(globalFilters)
+        internal Find(DBContext context, IMongoCollection<T> collection, Dictionary<Type, (object filterDef, bool prepend)> globalFilters) : base(globalFilters)
         {
             Context = context;
             Collection = collection;
         }
+
         public DBContext Context { get; private set; }
         public IMongoCollection<T> Collection { get; private set; }
 
-        public IClientSessionHandle? Session => Context.Session;
 
 
         /// <summary>
@@ -469,11 +298,12 @@ public Task<IAsyncCursor<TProjection>> ExecuteCursorAsync(CancellationToken canc
 
             var mergedFilter = Logic.MergeWithGlobalFilter(_ignoreGlobalFilters, _globalFilters, _filter);
 
-            return Session == null ?
+            return this.Session() is not IClientSessionHandle session ?
                 Collection.FindAsync(mergedFilter, _options, cancellation) :
-                Collection.FindAsync(Context.Session, mergedFilter, _options, cancellation);
+                Collection.FindAsync(session, mergedFilter, _options, cancellation);
         }
     }
+
     public enum Order
     {
         Ascending,
diff --git a/MongoDB.Entities/Builders/ICollectionRelated.cs b/MongoDB.Entities/Builders/ICollectionRelated.cs
new file mode 100644
index 000000000..5ca08ca05
--- /dev/null
+++ b/MongoDB.Entities/Builders/ICollectionRelated.cs
@@ -0,0 +1,21 @@
+using MongoDB.Driver;
+using System;
+using System.Collections.Generic;
+using System.Text;
+#nullable enable
+namespace MongoDB.Entities
+{
+    internal interface ICollectionRelated<T> where T : IEntity
+    {
+        public DBContext Context { get; }
+        public IMongoCollection<T> Collection { get; }
+    }
+    internal static class ICollectionRelatedExt
+    {
+        public static IClientSessionHandle? Session<T>(this ICollectionRelated<T> collectionRelated) where T : IEntity
+        {
+            return collectionRelated.Context.Session;
+        }
+
+    }
+}
diff --git a/MongoDB.Entities/Builders/Index.cs b/MongoDB.Entities/Builders/Index.cs
index fab18e129..3ed2209b6 100644
--- a/MongoDB.Entities/Builders/Index.cs
+++ b/MongoDB.Entities/Builders/Index.cs
@@ -12,15 +12,18 @@ namespace MongoDB.Entities
     /// <para>TIP: Define the keys first with .Key() method and finally call the .Create() method.</para>
     /// </summary>
     /// <typeparam name="T">Any class that implements IEntity</typeparam>
-    public class Index<T> where T : IEntity
+    public class Index<T> : ICollectionRelated<T> where T : IEntity
     {
         internal List<Key<T>> Keys { get; set; } = new List<Key<T>>();
-        private readonly CreateIndexOptions<T> options = new() { Background = true };
-        private readonly string tenantPrefix;
+        public DBContext Context { get; }
+        public IMongoCollection<T> Collection { get; }
 
-        internal Index(string tenantPrefix)
+        private readonly CreateIndexOptions<T> _options = new() { Background = true };
+
+        internal Index(DBContext context, IMongoCollection<T> collection)
         {
-            this.tenantPrefix = tenantPrefix;
+            Context = context;
+            Collection = collection;
         }
 
         /// <summary>
@@ -74,17 +77,17 @@ public async Task<string> CreateAsync(CancellationToken cancellation = default)
                 propNames.Add(key.PropertyName + keyType);
             }
 
-            if (string.IsNullOrEmpty(options.Name))
+            if (string.IsNullOrEmpty(_options.Name))
             {
                 if (isTextIndex)
-                    options.Name = "[TEXT]";
+                    _options.Name = "[TEXT]";
                 else
-                    options.Name = string.Join(" | ", propNames);
+                    _options.Name = string.Join(" | ", propNames);
             }
 
             var model = new CreateIndexModel<T>(
                 Builders<T>.IndexKeys.Combine(keyDefs),
-                options);
+                _options);
 
             try
             {
@@ -92,11 +95,11 @@ public async Task<string> CreateAsync(CancellationToken cancellation = default)
             }
             catch (MongoCommandException x) when (x.Code == 85 || x.Code == 86)
             {
-                await DropAsync(options.Name, cancellation).ConfigureAwait(false);
+                await DropAsync(_options.Name, cancellation).ConfigureAwait(false);
                 await CreateAsync(model, cancellation).ConfigureAwait(false);
             }
 
-            return options.Name;
+            return _options.Name;
         }
 
         /// <summary>
@@ -106,7 +109,7 @@ public async Task<string> CreateAsync(CancellationToken cancellation = default)
         /// <param name="option">x => x.OptionName = OptionValue</param>
         public Index<T> Option(Action<CreateIndexOptions<T>> option)
         {
-            option(options);
+            option(_options);
             return this;
         }
 
@@ -129,7 +132,7 @@ public Index<T> Key(Expression<Func<T, object>> propertyToIndex, KeyType type)
         /// <param name="cancellation">An optional cancellation token</param>
         public async Task DropAsync(string name, CancellationToken cancellation = default)
         {
-            await DB.Collection<T>(tenantPrefix).Indexes.DropOneAsync(name, cancellation).ConfigureAwait(false);
+            await Collection.Indexes.DropOneAsync(name, cancellation).ConfigureAwait(false);
         }
 
         /// <summary>
@@ -138,12 +141,12 @@ public async Task DropAsync(string name, CancellationToken cancellation = defaul
         /// <param name="cancellation">An optional cancellation token</param>
         public async Task DropAllAsync(CancellationToken cancellation = default)
         {
-            await DB.Collection<T>(tenantPrefix).Indexes.DropAllAsync(cancellation).ConfigureAwait(false);
+            await Collection.Indexes.DropAllAsync(cancellation).ConfigureAwait(false);
         }
 
         private Task CreateAsync(CreateIndexModel<T> model, CancellationToken cancellation = default)
         {
-            return DB.Collection<T>(tenantPrefix).Indexes.CreateOneAsync(model, cancellationToken: cancellation);
+            return Collection.Indexes.CreateOneAsync(model, cancellationToken: cancellation);
         }
     }
 
diff --git a/MongoDB.Entities/Builders/PagedSearch.cs b/MongoDB.Entities/Builders/PagedSearch.cs
index cb41fbfde..140a050e4 100644
--- a/MongoDB.Entities/Builders/PagedSearch.cs
+++ b/MongoDB.Entities/Builders/PagedSearch.cs
@@ -10,50 +10,21 @@
 
 namespace MongoDB.Entities
 {
-    /// <summary>
-    /// Represents an aggregation query that retrieves results with easy paging support.
-    /// </summary>
-    /// <typeparam name="T">Any class that implements IEntity</typeparam>
-    public class PagedSearch<T> : PagedSearch<T, T> where T : IEntity
-    {
-        internal PagedSearch(
-            IClientSessionHandle session,
-            Dictionary<Type, (object filterDef, bool prepend)> globalFilters,
-            string tenantPrefix)
-        : base(session, globalFilters, tenantPrefix) { }
-    }
-
-    /// <summary>
-    /// Represents an aggregation query that retrieves results with easy paging support.
-    /// </summary>
-    /// <typeparam name="T">Any class that implements IEntity</typeparam>
-    /// <typeparam name="TProjection">The type you'd like to project the results to.</typeparam>
-    public class PagedSearch<T, TProjection> where T : IEntity
+    public class PagedSearchBase<T, TProjection, TSelf> : SortFilterQueryBase<T, TSelf> where TSelf : PagedSearchBase<T, TProjection, TSelf> where T : IEntity
     {
-        private IAggregateFluent<T> fluentPipeline;
-        private FilterDefinition<T> filter = Builders<T>.Filter.Empty;
-        private readonly List<SortDefinition<T>> sorts = new();
-        private readonly AggregateOptions options = new();
-        private PipelineStageDefinition<T, TProjection> projectionStage;
-        private readonly IClientSessionHandle session;
-        private readonly Dictionary<Type, (object filterDef, bool prepend)> globalFilters;
-        private bool ignoreGlobalFilters;
-        private int pageNumber = 1, pageSize = 100;
-        private readonly string tenantPrefix;
-
-        internal PagedSearch(
-            IClientSessionHandle session,
-            Dictionary<Type, (object filterDef, bool prepend)> globalFilters,
-            string tenantPrefix)
+        internal PagedSearchBase(PagedSearchBase<T, TProjection, TSelf> other) : base(other)
         {
-            var type = typeof(TProjection);
-            if (type.IsPrimitive || type.IsValueType || (type == typeof(string)))
-                throw new NotSupportedException("Projecting to primitive types is not supported!");
+        }
 
-            this.session = session;
-            this.globalFilters = globalFilters;
-            this.tenantPrefix = tenantPrefix;
+        internal PagedSearchBase(Dictionary<Type, (object filterDef, bool prepend)> globalFilters) : base(globalFilters)
+        {
         }
+        private TSelf This => (TSelf)this;
+
+        internal IAggregateFluent<T>? _fluentPipeline;
+        internal AggregateOptions _options = new();
+        internal PipelineStageDefinition<T, TProjection>? _projectionStage;
+        internal int _pageNumber = 1, _pageSize = 100;
 
         /// <summary>
         /// Begins the paged search aggregation pipeline with the provided fluent pipeline.
@@ -61,150 +32,21 @@ internal PagedSearch(
         /// </summary>
         /// <typeparam name="TFluent">The type of the input pipeline</typeparam>
         /// <param name="fluentPipeline">The input IAggregateFluent pipeline</param>
-        public PagedSearch<T, TProjection> WithFluent<TFluent>(TFluent fluentPipeline) where TFluent : IAggregateFluent<T>
-        {
-            this.fluentPipeline = fluentPipeline;
-            return this;
-        }
-
-        /// <summary>
-        /// Specify the matching criteria with a lambda expression
-        /// </summary>
-        /// <param name="expression">x => x.Property == Value</param>
-        public PagedSearch<T, TProjection> Match(Expression<Func<T, bool>> expression)
-        {
-            return Match(f => f.Where(expression));
-        }
-
-        /// <summary>
-        /// Specify the matching criteria with a filter expression
-        /// </summary>
-        /// <param name="filter">f => f.Eq(x => x.Prop, Value) &amp; f.Gt(x => x.Prop, Value)</param>
-        public PagedSearch<T, TProjection> Match(Func<FilterDefinitionBuilder<T>, FilterDefinition<T>> filter)
-        {
-            this.filter &= filter(Builders<T>.Filter);
-            return this;
-        }
-
-        /// <summary>
-        /// Specify the matching criteria with a filter definition
-        /// </summary>
-        /// <param name="filterDefinition">A filter definition</param>
-        public PagedSearch<T, TProjection> Match(FilterDefinition<T> filterDefinition)
-        {
-            filter &= filterDefinition;
-            return this;
-        }
-
-        /// <summary>
-        /// Specify the matching criteria with a template
-        /// </summary>
-        /// <param name="template">A Template with a find query</param>
-        public PagedSearch<T, TProjection> Match(Template template)
-        {
-            filter &= template.RenderToString();
-            return this;
-        }
-
-        /// <summary>
-        /// Specify a search term to find results from the text index of this particular collection.
-        /// <para>TIP: Make sure to define a text index with DB.Index&lt;T&gt;() before searching</para>
-        /// </summary>
-        /// <param name="searchType">The type of text matching to do</param>
-        /// <param name="searchTerm">The search term</param>
-        /// <param name="caseSensitive">Case sensitivity of the search (optional)</param>
-        /// <param name="diacriticSensitive">Diacritic sensitivity of the search (optional)</param>
-        /// <param name="language">The language for the search (optional)</param>
-        public PagedSearch<T, TProjection> Match(Search searchType, string searchTerm, bool caseSensitive = false, bool diacriticSensitive = false, string language = null)
-        {
-            if (searchType == Search.Fuzzy)
-            {
-                searchTerm = searchTerm.ToDoubleMetaphoneHash();
-                caseSensitive = false;
-                diacriticSensitive = false;
-                language = null;
-            }
-
-            return Match(
-                f => f.Text(
-                    searchTerm,
-                    new TextSearchOptions
-                    {
-                        CaseSensitive = caseSensitive,
-                        DiacriticSensitive = diacriticSensitive,
-                        Language = language
-                    }));
-        }
-
-        /// <summary>
-        /// Specify criteria for matching entities based on GeoSpatial data (longitude &amp; latitude)
-        /// <para>TIP: Make sure to define a Geo2DSphere index with DB.Index&lt;T&gt;() before searching</para>
-        /// <para>Note: DB.FluentGeoNear() supports more advanced options</para>
-        /// </summary>
-        /// <param name="coordinatesProperty">The property where 2DCoordinates are stored</param>
-        /// <param name="nearCoordinates">The search point</param>
-        /// <param name="maxDistance">Maximum distance in meters from the search point</param>
-        /// <param name="minDistance">Minimum distance in meters from the search point</param>
-        public PagedSearch<T, TProjection> Match(Expression<Func<T, object>> coordinatesProperty, Coordinates2D nearCoordinates, double? maxDistance = null, double? minDistance = null)
+        public TSelf WithFluent<TFluent>(TFluent fluentPipeline) where TFluent : IAggregateFluent<T>
         {
-            return Match(f => f.Near(coordinatesProperty, nearCoordinates.ToGeoJsonPoint(), maxDistance, minDistance));
+            this._fluentPipeline = fluentPipeline;
+            return This;
         }
 
-        /// <summary>
-        /// Specify the matching criteria with a JSON string
-        /// </summary>
-        /// <param name="jsonString">{ Title : 'The Power Of Now' }</param>
-        public PagedSearch<T, TProjection> MatchString(string jsonString)
-        {
-            filter &= jsonString;
-            return this;
-        }
 
-        /// <summary>
-        /// Specify the matching criteria with an aggregation expression (i.e. $expr)
-        /// </summary>
-        /// <param name="expression">{ $gt: ['$Property1', '$Property2'] }</param>
-        public PagedSearch<T, TProjection> MatchExpression(string expression)
-        {
-            filter &= "{$expr:" + expression + "}";
-            return this;
-        }
 
-        /// <summary>
-        /// Specify the matching criteria with a Template
-        /// </summary>
-        /// <param name="template">A Template object</param>
-        public PagedSearch<T, TProjection> MatchExpression(Template template)
-        {
-            filter &= "{$expr:" + template.RenderToString() + "}";
-            return this;
-        }
 
-        /// <summary>
-        /// Specify which property and order to use for sorting (use multiple times if needed)
-        /// </summary>
-        /// <param name="propertyToSortBy">x => x.Prop</param>
-        /// <param name="sortOrder">The sort order</param>
-        public PagedSearch<T, TProjection> Sort(Expression<Func<T, object>> propertyToSortBy, Order sortOrder)
-        {
-            switch (sortOrder)
-            {
-                case Order.Ascending:
-                    return Sort(s => s.Ascending(propertyToSortBy));
-
-                case Order.Descending:
-                    return Sort(s => s.Descending(propertyToSortBy));
-
-                default:
-                    return this;
-            }
-        }
 
         /// <summary>
         /// Sort the results of a text search by the MetaTextScore
         /// <para>TIP: Use this method after .Project() if you need to do a projection also</para>
         /// </summary>
-        public PagedSearch<T, TProjection> SortByTextScore()
+        public TSelf SortByTextScore()
         {
             return SortByTextScore(null);
         }
@@ -214,7 +56,7 @@ public PagedSearch<T, TProjection> SortByTextScore()
         /// <para>TIP: Use this method after .Project() if you need to do a projection also</para>
         /// </summary>
         /// <param name="scoreProperty">x => x.TextScoreProp</param>
-        public PagedSearch<T, TProjection> SortByTextScore(Expression<Func<T, object>> scoreProperty)
+        public TSelf SortByTextScore(Expression<Func<T, object>>? scoreProperty)
         {
             switch (scoreProperty)
             {
@@ -230,81 +72,73 @@ public PagedSearch<T, TProjection> SortByTextScore(Expression<Func<T, object>> s
 
         private void AddTxtScoreToProjection(string fieldName)
         {
-            if (projectionStage == null)
+            if (_projectionStage == null)
             {
-                projectionStage = $"{{ $set : {{ {fieldName} : {{ $meta : 'textScore' }}  }} }}";
+                _projectionStage = $"{{ $set : {{ {fieldName} : {{ $meta : 'textScore' }}  }} }}";
                 return;
             }
 
-            var renderedStage = projectionStage.Render(
+            var renderedStage = _projectionStage.Render(
                 BsonSerializer.SerializerRegistry.GetSerializer<T>(),
                 BsonSerializer.SerializerRegistry);
 
             renderedStage.Document["$project"][fieldName] = new BsonDocument { { "$meta", "textScore" } };
 
-            projectionStage = renderedStage.Document;
+            _projectionStage = renderedStage.Document;
         }
 
-        /// <summary>
-        /// Specify how to sort using a sort expression
-        /// </summary>
-        /// <param name="sortFunction">s => s.Ascending("Prop1").MetaTextScore("Prop2")</param>
-        public PagedSearch<T, TProjection> Sort(Func<SortDefinitionBuilder<T>, SortDefinition<T>> sortFunction)
-        {
-            sorts.Add(sortFunction(Builders<T>.Sort));
-            return this;
-        }
+
 
         /// <summary>
         /// Specify the page number to get
         /// </summary>
         /// <param name="pageNumber">The page number</param>
-        public PagedSearch<T, TProjection> PageNumber(int pageNumber)
+        public TSelf PageNumber(int pageNumber)
         {
-            this.pageNumber = pageNumber;
-            return this;
+            this._pageNumber = pageNumber;
+            return This;
         }
 
         /// <summary>
         /// Specify the number of items per page
         /// </summary>
         /// <param name="pageSize">The size of a page</param>
-        public PagedSearch<T, TProjection> PageSize(int pageSize)
+        public TSelf PageSize(int pageSize)
         {
-            this.pageSize = pageSize;
-            return this;
+            this._pageSize = pageSize;
+            return This;
         }
 
         /// <summary>
         /// Specify how to project the results using a lambda expression
         /// </summary>
         /// <param name="expression">x => new Test { PropName = x.Prop }</param>
-        public PagedSearch<T, TProjection> Project(Expression<Func<T, TProjection>> expression)
+        public TSelf Project(Expression<Func<T, TProjection>> expression)
         {
-            projectionStage = PipelineStageDefinitionBuilder.Project(expression);
-            return this;
+            _projectionStage = PipelineStageDefinitionBuilder.Project(expression);
+            return This;
         }
 
         /// <summary>
         /// Specify how to project the results using a projection expression
         /// </summary>
         /// <param name="projection">p => p.Include("Prop1").Exclude("Prop2")</param>
-        public PagedSearch<T, TProjection> Project(Func<ProjectionDefinitionBuilder<T>, ProjectionDefinition<T, TProjection>> projection)
+        public TSelf Project(Func<ProjectionDefinitionBuilder<T>, ProjectionDefinition<T, TProjection>> projection)
         {
-            projectionStage = PipelineStageDefinitionBuilder.Project(projection(Builders<T>.Projection));
-            return this;
+            _projectionStage = PipelineStageDefinitionBuilder.Project(projection(Builders<T>.Projection));
+            return This;
         }
 
         /// <summary>
         /// Specify how to project the results using an exclusion projection expression.
         /// </summary>
         /// <param name="exclusion">x => new { x.PropToExclude, x.AnotherPropToExclude }</param>
-        public PagedSearch<T, TProjection> ProjectExcluding(Expression<Func<T, object>> exclusion)
+        public TSelf ProjectExcluding(Expression<Func<T, object>> exclusion)
         {
             var props = (exclusion.Body as NewExpression)?.Arguments
                 .Select(a => a.ToString().Split('.')[1]);
 
-            if (!props.Any())
+            if (props == null || !props.Any())
                 throw new ArgumentException("Unable to get any properties from the exclusion expression!");
 
             var defs = new List<ProjectionDefinition<T>>(props.Count());
@@ -314,51 +148,79 @@ public PagedSearch<T, TProjection> ProjectExcluding(Expression<Func<T, object>>
                 defs.Add(Builders<T>.Projection.Exclude(prop));
             }
 
-            projectionStage = PipelineStageDefinitionBuilder.Project<T, TProjection>(Builders<T>.Projection.Combine(defs));
+            _projectionStage = PipelineStageDefinitionBuilder.Project<T, TProjection>(Builders<T>.Projection.Combine(defs));
 
-            return this;
+            return This;
         }
 
         /// <summary>
         /// Specify an option for this find command (use multiple times if needed)
         /// </summary>
         /// <param name="option">x => x.OptionName = OptionValue</param>
-        public PagedSearch<T, TProjection> Option(Action<AggregateOptions> option)
+        public TSelf Option(Action<AggregateOptions> option)
         {
-            option(options);
-            return this;
+            option(_options);
+            return This;
         }
 
-        /// <summary>
-        /// Specify that this operation should ignore any global filters
-        /// </summary>
-        public PagedSearch<T, TProjection> IgnoreGlobalFilters()
+
+    }
+
+    /// <summary>
+    /// Represents an aggregation query that retrieves results with easy paging support.
+    /// </summary>
+    /// <typeparam name="T">Any class that implements IEntity</typeparam>
+    public class PagedSearch<T> : PagedSearch<T, T> where T : IEntity
+    {
+        internal PagedSearch(
+            DBContext context, IMongoCollection<T> collection,
+            Dictionary<Type, (object filterDef, bool prepend)> globalFilters)
+        : base(context, collection, globalFilters) { }
+    }
+
+    /// <summary>
+    /// Represents an aggregation query that retrieves results with easy paging support.
+    /// </summary>
+    /// <typeparam name="T">Any class that implements IEntity</typeparam>
+    /// <typeparam name="TProjection">The type you'd like to project the results to.</typeparam>
+    public class PagedSearch<T, TProjection> : PagedSearchBase<T, TProjection, PagedSearch<T, TProjection>> where T : IEntity
+    {
+
+        public DBContext Context { get; set; }
+        public IMongoCollection<T> Collection { get; set; }
+
+        internal PagedSearch(DBContext context, IMongoCollection<T> collection, Dictionary<Type, (object filterDef, bool prepend)> globalFilters) : base(globalFilters)
         {
-            ignoreGlobalFilters = true;
-            return this;
+            var type = typeof(TProjection);
+            if (type.IsPrimitive || type.IsValueType || (type == typeof(string)))
+                throw new NotSupportedException("Projecting to primitive types is not supported!");
+            Context = context;
+            Collection = collection;
         }
 
+
+
         /// <summary>
         /// Run the aggregation search command in MongoDB server and get a page of results and total + page count
         /// </summary>
         /// <param name="cancellation">An optional cancellation token</param>
         public async Task<(IReadOnlyList<TProjection> Results, long TotalCount, int PageCount)> ExecuteAsync(CancellationToken cancellation = default)
         {
-            if (filter != Builders<T>.Filter.Empty && fluentPipeline != null)
+            if (_filter != Builders<T>.Filter.Empty && _fluentPipeline != null)
                 throw new InvalidOperationException(".Match() and .WithFluent() cannot be used together!");
 
             var pipelineStages = new List<IPipelineStageDefinition>(4);
 
-            if (sorts.Count == 0)
+            if (_sorts.Count == 0)
                 throw new InvalidOperationException("Paging without sorting is a sin!");
             else
-                pipelineStages.Add(PipelineStageDefinitionBuilder.Sort(Builders<T>.Sort.Combine(sorts)));
+                pipelineStages.Add(PipelineStageDefinitionBuilder.Sort(Builders<T>.Sort.Combine(_sorts)));
 
-            pipelineStages.Add(PipelineStageDefinitionBuilder.Skip<T>((pageNumber - 1) * pageSize));
-            pipelineStages.Add(PipelineStageDefinitionBuilder.Limit<T>(pageSize));
+            pipelineStages.Add(PipelineStageDefinitionBuilder.Skip<T>((_pageNumber - 1) * _pageSize));
+            pipelineStages.Add(PipelineStageDefinitionBuilder.Limit<T>(_pageSize));
 
-            if (projectionStage != null)
-                pipelineStages.Add(projectionStage);
+            if (_projectionStage != null)
+                pipelineStages.Add(_projectionStage);
 
             var resultsFacet = AggregateFacet.Create<T, TProjection>("_results", pipelineStages);
 
@@ -370,18 +232,18 @@ public PagedSearch<T, TProjection> IgnoreGlobalFilters()
 
             AggregateFacetResults facetResult;
 
-            if (fluentPipeline == null) //.Match() used
+            if (_fluentPipeline == null) //.Match() used
             {
-                var filterDef = Logic.MergeWithGlobalFilter(ignoreGlobalFilters, globalFilters, filter);
+                var filterDef = Logic.MergeWithGlobalFilter(_ignoreGlobalFilters, _globalFilters, _filter);
 
                 facetResult =
-                    session == null
-                    ? await DB.Collection<T>(tenantPrefix).Aggregate(options).Match(filterDef).Facet(countFacet, resultsFacet).SingleAsync(cancellation).ConfigureAwait(false)
-                    : await DB.Collection<T>(tenantPrefix).Aggregate(session, options).Match(filterDef).Facet(countFacet, resultsFacet).SingleAsync(cancellation).ConfigureAwait(false);
+                    Context.Session is not IClientSessionHandle session
+                    ? await Collection.Aggregate(_options).Match(filterDef).Facet(countFacet, resultsFacet).SingleAsync(cancellation).ConfigureAwait(false)
+                    : await Collection.Aggregate(session, _options).Match(filterDef).Facet(countFacet, resultsFacet).SingleAsync(cancellation).ConfigureAwait(false);
             }
             else //.WithFluent() used
             {
-                facetResult = await fluentPipeline
+                facetResult = await _fluentPipeline
                     .Facet(countFacet, resultsFacet)
                     .SingleAsync(cancellation)
                     .ConfigureAwait(false);
@@ -394,9 +256,9 @@ public PagedSearch<T, TProjection> IgnoreGlobalFilters()
             ) ?? 0;
 
             int pageCount =
-                 matchCount > 0 && matchCount <= pageSize
+                 matchCount > 0 && matchCount <= _pageSize
                  ? 1
-                 : (int)Math.Ceiling((double)matchCount / pageSize);
+                 : (int)Math.Ceiling((double)matchCount / _pageSize);
 
             var results = facetResult.Facets
                 .First(x => x.Name == "_results")
diff --git a/MongoDB.Entities/Builders/Replace.cs b/MongoDB.Entities/Builders/Replace.cs
index b05408e34..fe25a2044 100644
--- a/MongoDB.Entities/Builders/Replace.cs
+++ b/MongoDB.Entities/Builders/Replace.cs
@@ -14,154 +14,30 @@ namespace MongoDB.Entities
     /// <para>TIP: Specify a filter first with the .Match(). Then set entity with .WithEntity() and finally call .Execute() to run the command.</para>
     /// </summary>
     /// <typeparam name="T">Any class that implements IEntity</typeparam>
-    public class Replace<T> where T : IEntity
+    public class Replace<T> : FilterQueryBase<T, Replace<T>>, ICollectionRelated<T> where T : IEntity
     {
-        private FilterDefinition<T> filter = Builders<T>.Filter.Empty;
-        private ReplaceOptions options = new();
-        private readonly IClientSessionHandle session;
-        private readonly List<ReplaceOneModel<T>> models = new();
-        private readonly ModifiedBy modifiedBy;
-        private readonly Dictionary<Type, (object filterDef, bool prepend)> globalFilters;
-        private readonly Action<T> onSaveAction;
-        private bool ignoreGlobalFilters;
-        private readonly string tenantPrefix;
-        private T entity;
+        private ReplaceOptions _options = new();
+        private readonly List<ReplaceOneModel<T>> _models = new();
+        private readonly ModifiedBy? _modifiedBy;
+        private readonly Action<T> _onSaveAction;
+        private T? _entity;
+
+        public DBContext Context { get; }
+        public IMongoCollection<T> Collection { get; }
 
         internal Replace(
-            IClientSessionHandle session,
+            DBContext context,
+            IMongoCollection<T> collection,
             ModifiedBy modifiedBy,
             Dictionary<Type, (object filterDef, bool prepend)> globalFilters,
-            Action<T> onSaveAction,
-            string tenantPrefix)
-        {
-            this.session = session;
-            this.modifiedBy = modifiedBy;
-            this.globalFilters = globalFilters;
-            this.onSaveAction = onSaveAction;
-            this.tenantPrefix = tenantPrefix;
-        }
-
-        /// <summary>
-        /// Specify an IEntity ID as the matching criteria
-        /// </summary>
-        /// <param name="ID">A unique IEntity ID</param>
-        public Replace<T> MatchID(string ID)
-        {
-            return Match(f => f.Eq(t => t.ID, ID));
-        }
-
-        /// <summary>
-        /// Specify the matching criteria with a lambda expression
-        /// </summary>
-        /// <param name="expression">x => x.Property == Value</param>
-        public Replace<T> Match(Expression<Func<T, bool>> expression)
-        {
-            return Match(f => f.Where(expression));
-        }
-
-        /// <summary>
-        /// Specify the matching criteria with a filter expression
-        /// </summary>
-        /// <param name="filter">f => f.Eq(x => x.Prop, Value) &amp; f.Gt(x => x.Prop, Value)</param>
-        public Replace<T> Match(Func<FilterDefinitionBuilder<T>, FilterDefinition<T>> filter)
-        {
-            this.filter &= filter(Builders<T>.Filter);
-            return this;
-        }
-
-        /// <summary>
-        /// Specify the matching criteria with a filter definition
-        /// </summary>
-        /// <param name="filterDefinition">A filter definition</param>
-        public Replace<T> Match(FilterDefinition<T> filterDefinition)
-        {
-            filter &= filterDefinition;
-            return this;
-        }
-
-        /// <summary>
-        /// Specify the matching criteria with a template
-        /// </summary>
-        /// <param name="template">A Template with a find query</param>
-        public Replace<T> Match(Template template)
-        {
-            filter &= template.RenderToString();
-            return this;
-        }
-
-        /// <summary>
-        /// Specify a search term to find results from the text index of this particular collection.
-        /// <para>TIP: Make sure to define a text index with DB.Index&lt;T&gt;() before searching</para>
-        /// </summary>
-        /// <param name="searchType">The type of text matching to do</param>
-        /// <param name="searchTerm">The search term</param>
-        /// <param name="caseSensitive">Case sensitivity of the search (optional)</param>
-        /// <param name="diacriticSensitive">Diacritic sensitivity of the search (optional)</param>
-        /// <param name="language">The language for the search (optional)</param>
-        public Replace<T> Match(Search searchType, string searchTerm, bool caseSensitive = false, bool diacriticSensitive = false, string language = null)
+            Action<T> onSaveAction) : base(globalFilters)
         {
-            if (searchType == Search.Fuzzy)
-            {
-                searchTerm = searchTerm.ToDoubleMetaphoneHash();
-                caseSensitive = false;
-                diacriticSensitive = false;
-                language = null;
-            }
-
-            return Match(
-                f => f.Text(
-                    searchTerm,
-                    new TextSearchOptions
-                    {
-                        CaseSensitive = caseSensitive,
-                        DiacriticSensitive = diacriticSensitive,
-                        Language = language
-                    }));
+            Context = context;
+            Collection = collection;
+            this._modifiedBy = modifiedBy;
+            this._onSaveAction = onSaveAction;
         }
 
-        /// <summary>
-        /// Specify criteria for matching entities based on GeoSpatial data (longitude &amp; latitude)
-        /// <para>TIP: Make sure to define a Geo2DSphere index with DB.Index&lt;T&gt;() before searching</para>
-        /// <para>Note: DB.FluentGeoNear() supports more advanced options</para>
-        /// </summary>
-        /// <param name="coordinatesProperty">The property where 2DCoordinates are stored</param>
-        /// <param name="nearCoordinates">The search point</param>
-        /// <param name="maxDistance">Maximum distance in meters from the search point</param>
-        /// <param name="minDistance">Minimum distance in meters from the search point</param>
-        public Replace<T> Match(Expression<Func<T, object>> coordinatesProperty, Coordinates2D nearCoordinates, double? maxDistance = null, double? minDistance = null)
-        {
-            return Match(f => f.Near(coordinatesProperty, nearCoordinates.ToGeoJsonPoint(), maxDistance, minDistance));
-        }
-
-        /// <summary>
-        /// Specify the matching criteria with a JSON string
-        /// </summary>
-        /// <param name="jsonString">{ Title : 'The Power Of Now' }</param>
-        public Replace<T> MatchString(string jsonString)
-        {
-            filter &= jsonString;
-            return this;
-        }
-
-        /// <summary>
-        /// Specify the matching criteria with an aggregation expression (i.e. $expr)
-        /// </summary>
-        /// <param name="expression">{ $gt: ['$Property1', '$Property2'] }</param>
-        public Replace<T> MatchExpression(string expression)
-        {
-            filter &= "{$expr:" + expression + "}";
-            return this;
-        }
-
-        /// <summary>
-        /// Specify the matching criteria with a Template
-        /// </summary>
-        /// <param name="template">A Template object</param>
-        public Replace<T> MatchExpression(Template template)
-        {
-            filter &= "{$expr:" + template.RenderToString() + "}";
-            return this;
-        }
 
         /// <summary>
         /// Supply the entity to replace the first matched document with
@@ -173,12 +49,9 @@ public Replace<T> WithEntity(T entity)
             if (string.IsNullOrEmpty(entity.ID))
                 throw new InvalidOperationException("Cannot replace an entity with an empty ID value!");
 
-            onSaveAction?.Invoke(entity);
-
-            this.entity = entity;
-
-            this.entity.SetTenantPrefixOnFileEntity(tenantPrefix);
+            _onSaveAction?.Invoke(entity);
 
+            this._entity = entity;
             return this;
         }
 
@@ -189,38 +62,30 @@ public Replace<T> WithEntity(T entity)
         /// <param name="option">x => x.OptionName = OptionValue</param>
         public Replace<T> Option(Action<ReplaceOptions> option)
         {
-            option(options);
+            option(_options);
             return this;
         }
 
-        /// <summary>
-        /// Specify that this operation should ignore any global filters
-        /// </summary>
-        public Replace<T> IgnoreGlobalFilters()
-        {
-            ignoreGlobalFilters = true;
-            return this;
-        }
 
         /// <summary>
         /// Queue up a replace command for bulk execution later.
         /// </summary>
         public Replace<T> AddToQueue()
         {
-            var mergedFilter = Logic.MergeWithGlobalFilter(ignoreGlobalFilters, globalFilters, filter);
+            var mergedFilter = Logic.MergeWithGlobalFilter(_ignoreGlobalFilters, _globalFilters, _filter);
             if (mergedFilter == Builders<T>.Filter.Empty) throw new ArgumentException("Please use Match() method first!");
-            if (entity == null) throw new ArgumentException("Please use WithEntity() method first!");
+            if (_entity == null) throw new ArgumentException("Please use WithEntity() method first!");
             SetModOnAndByValues();
 
-            models.Add(new ReplaceOneModel<T>(mergedFilter, entity)
+            _models.Add(new ReplaceOneModel<T>(mergedFilter, _entity)
             {
-                Collation = options.Collation,
-                Hint = options.Hint,
-                IsUpsert = options.IsUpsert
+                Collation = _options.Collation,
+                Hint = _options.Hint,
+                IsUpsert = _options.IsUpsert
             });
-            filter = Builders<T>.Filter.Empty;
-            entity = default;
-            options = new ReplaceOptions();
+            _filter = Builders<T>.Filter.Empty;
+            _entity = default;
+            _options = new ReplaceOptions();
             return this;
         }
 
@@ -230,15 +95,15 @@ public Replace<T> AddToQueue()
         /// <param name="cancellation">An optional cancellation token</param>
         public async Task<ReplaceOneResult> ExecuteAsync(CancellationToken cancellation = default)
         {
-            if (models.Count > 0)
+            if (_models.Count > 0)
             {
                 var bulkWriteResult = await (
-                    session == null
-                    ? DB.Collection<T>(tenantPrefix).BulkWriteAsync(models, null, cancellation)
-                    : DB.Collection<T>(tenantPrefix).BulkWriteAsync(session, models, null, cancellation)
+                    this.Session() is not IClientSessionHandle session
+                    ? Collection.BulkWriteAsync(_models, null, cancellation)
+                    : Collection.BulkWriteAsync(session, _models, null, cancellation)
                     ).ConfigureAwait(false);
 
-                models.Clear();
+                _models.Clear();
 
                 if (!bulkWriteResult.IsAcknowledged)
                     return ReplaceOneResult.Unacknowledged.Instance;
@@ -247,25 +112,25 @@ public async Task<ReplaceOneResult> ExecuteAsync(CancellationToken cancellation
             }
             else
             {
-                var mergedFilter = Logic.MergeWithGlobalFilter(ignoreGlobalFilters, globalFilters, filter);
+                var mergedFilter = MergedFilter;
                 if (mergedFilter == Builders<T>.Filter.Empty) throw new ArgumentException("Please use Match() method first!");
-                if (entity == null) throw new ArgumentException("Please use WithEntity() method first!");
+                if (_entity == null) throw new ArgumentException("Please use WithEntity() method first!");
                 SetModOnAndByValues();
 
-                return session == null
-                       ? await DB.Collection<T>(tenantPrefix).ReplaceOneAsync(mergedFilter, entity, options, cancellation).ConfigureAwait(false)
-                       : await DB.Collection<T>(tenantPrefix).ReplaceOneAsync(session, mergedFilter, entity, options, cancellation).ConfigureAwait(false);
+                return this.Session() is not IClientSessionHandle session
+                       ? await Collection.ReplaceOneAsync(mergedFilter, _entity, _options, cancellation).ConfigureAwait(false)
+                       : await Collection.ReplaceOneAsync(session, mergedFilter, _entity, _options, cancellation).ConfigureAwait(false);
             }
         }
 
         private void SetModOnAndByValues()
         {
-            if (Cache<T>.HasModifiedOn) ((IModifiedOn)entity).ModifiedOn = DateTime.UtcNow;
-            if (Cache<T>.ModifiedByProp != null && modifiedBy != null)
+            if (Cache<T>.Instance.HasModifiedOn && _entity is IModifiedOn _entityModifiedOn) _entityModifiedOn.ModifiedOn = DateTime.UtcNow;
+            if (Cache<T>.Instance.ModifiedByProp != null && _modifiedBy != null)
             {
-                Cache<T>.ModifiedByProp.SetValue(
-                    entity,
-                    BsonSerializer.Deserialize(modifiedBy.ToBson(), Cache<T>.ModifiedByProp.PropertyType));
+                Cache<T>.Instance.ModifiedByProp.SetValue(
+                    _entity,
+                    BsonSerializer.Deserialize(_modifiedBy.ToBson(), Cache<T>.Instance.ModifiedByProp.PropertyType));
             }
         }
     }
diff --git a/MongoDB.Entities/Builders/SortFilterQueryBase.cs b/MongoDB.Entities/Builders/SortFilterQueryBase.cs
new file mode 100644
index 000000000..f127f8f0a
--- /dev/null
+++ b/MongoDB.Entities/Builders/SortFilterQueryBase.cs
@@ -0,0 +1,49 @@
+using MongoDB.Driver;
+using System;
+using System.Collections.Generic;
+using System.Linq.Expressions;
+#nullable enable
+namespace MongoDB.Entities
+{
+    public class SortFilterQueryBase<T, TSelf> : FilterQueryBase<T, TSelf> where T : IEntity where TSelf : SortFilterQueryBase<T, TSelf>
+    {
+        internal List<SortDefinition<T>> _sorts = new();
+        private TSelf This => (TSelf)this;
+
+        internal SortFilterQueryBase(SortFilterQueryBase<T, TSelf> other) : base(other)
+        {
+            _sorts = other._sorts;
+        }
+        internal SortFilterQueryBase(Dictionary<Type, (object filterDef, bool prepend)> globalFilters) : base(globalFilters: globalFilters)
+        {
+            _globalFilters = globalFilters;
+        }
+
+
+        /// <summary>
+        /// Specify which property and order to use for sorting (use multiple times if needed)
+        /// </summary>
+        /// <param name="propertyToSortBy">x => x.Prop</param>
+        /// <param name="sortOrder">The sort order</param>
+        public TSelf Sort(Expression<Func<T, object>> propertyToSortBy, Order sortOrder)
+        {
+            return sortOrder switch
+            {
+                Order.Ascending => Sort(s => s.Ascending(propertyToSortBy)),
+                Order.Descending => Sort(s => s.Descending(propertyToSortBy)),
+                _ => This,
+            };
+        }
+
+        /// <summary>
+        /// Specify how to sort using a sort expression
+        /// </summary>
+        /// <param name="sortFunction">s => s.Ascending("Prop1").MetaTextScore("Prop2")</param>
+        /// <returns></returns>
+        public TSelf Sort(Func<SortDefinitionBuilder<T>, SortDefinition<T>> sortFunction)
+        {
+            _sorts.Add(sortFunction(Builders<T>.Sort));
+            return This;
+        }
+    }
+}
diff --git a/MongoDB.Entities/Builders/Update.cs b/MongoDB.Entities/Builders/Update.cs
index bfeba3164..86bad7a9e 100644
--- a/MongoDB.Entities/Builders/Update.cs
+++ b/MongoDB.Entities/Builders/Update.cs
@@ -9,13 +9,21 @@
 
 namespace MongoDB.Entities
 {
-    public abstract class UpdateBase<T> where T : IEntity
+    public class UpdateBase<T, TSelf> : FilterQueryBase<T, TSelf> where T : IEntity where TSelf : UpdateBase<T, TSelf>
     {
         //note: this base class exists for facilating the OnBeforeUpdate custom hook of DBContext class
         //      there's no other purpose for this.
 
         protected readonly List<UpdateDefinition<T>> defs = new();
 
+        internal UpdateBase(FilterQueryBase<T, TSelf> other) : base(other)
+        {
+        }
+
+        internal UpdateBase(Dictionary<Type, (object filterDef, bool prepend)> globalFilters) : base(globalFilters)
+        {
+        }
+
         /// <summary>
         /// Specify the property and it's value to modify (use multiple times if needed)
         /// </summary>
@@ -53,15 +61,15 @@ public void AddModification(Template template)
             AddModification(template.RenderToString());
         }
 
-        protected void SetTenantDbOnFileEntities(string tenantPrefix)
-        {
-            if (Cache<T>.IsFileEntity)
-            {
-                defs.Add(Builders<T>.Update.Set(
-                    nameof(FileEntity.TenantPrefix),
-                    Cache<T>.Collection(tenantPrefix).Database.DatabaseNamespace.DatabaseName));
-            }
-        }
+        //protected void SetTenantDbOnFileEntities(string tenantPrefix)
+        //{
+        //    if (Cache<T>.Instance.IsFileEntity)
+        //    {
+        //        defs.Add(Builders<T>.Update.Set(
+        //            nameof(FileEntity.TenantPrefix),
+        //            Cache<T>.Instance.Collection(tenantPrefix).Database.DatabaseNamespace.DatabaseName));
+        //    }
+        //}
     }
 
     /// <summary>
@@ -69,151 +77,29 @@ protected void SetTenantDbOnFileEntities(string tenantPrefix)
     /// <para>TIP: Specify a filter first with the .Match(). Then set property values with .Modify() and finally call .Execute() to run the command.</para>
     /// </summary>
     /// <typeparam name="T">Any class that implements IEntity</typeparam>
-    public class Update<T> : UpdateBase<T> where T : IEntity
+    public class Update<T> : UpdateBase<T, Update<T>>, ICollectionRelated<T> where T : IEntity
     {
-        private readonly List<PipelineStageDefinition<T, T>> stages = new();
-        private FilterDefinition<T> filter = Builders<T>.Filter.Empty;
-        private UpdateOptions options = new();
-        private readonly IClientSessionHandle session;
-        private readonly List<UpdateManyModel<T>> models = new();
-        private readonly Dictionary<Type, (object filterDef, bool prepend)> globalFilters;
-        private readonly Action<UpdateBase<T>> onUpdateAction;
-        private bool ignoreGlobalFilters;
-        private readonly string tenantPrefix;
+        private readonly List<PipelineStageDefinition<T, T>> _stages = new();
+        private UpdateOptions _options = new();
+        private readonly List<UpdateManyModel<T>> _models = new();
+        private readonly Action<Update<T>> _onUpdateAction;
+
+        public DBContext Context { get; }
+        public IMongoCollection<T> Collection { get; }
 
         internal Update(
-            IClientSessionHandle session,
+            DBContext context,
+            IMongoCollection<T> collection,
             Dictionary<Type, (object filterDef, bool prepend)> globalFilters,
-            Action<UpdateBase<T>> onUpdateAction,
-            string tenantPrefix)
-        {
-            this.session = session;
-            this.globalFilters = globalFilters;
-            this.onUpdateAction = onUpdateAction;
-            this.tenantPrefix = tenantPrefix;
-        }
-
-        /// <summary>
-        /// Specify an IEntity ID as the matching criteria
-        /// </summary>
-        /// <param name="ID">A unique IEntity ID</param>
-        public Update<T> MatchID(string ID)
-        {
-            return Match(f => f.Eq(t => t.ID, ID));
-        }
-
-        /// <summary>
-        /// Specify the matching criteria with a lambda expression
-        /// </summary>
-        /// <param name="expression">x => x.Property == Value</param>
-        public Update<T> Match(Expression<Func<T, bool>> expression)
+            Action<Update<T>> onUpdateAction) :
+            base(globalFilters)
         {
-            return Match(f => f.Where(expression));
+            Context = context;
+            Collection = collection;
+            _onUpdateAction = onUpdateAction;
         }
 
-        /// <summary>
-        /// Specify the matching criteria with a filter expression
-        /// </summary>
-        /// <param name="filter">f => f.Eq(x => x.Prop, Value) &amp; f.Gt(x => x.Prop, Value)</param>
-        public Update<T> Match(Func<FilterDefinitionBuilder<T>, FilterDefinition<T>> filter)
-        {
-            this.filter &= filter(Builders<T>.Filter);
-            return this;
-        }
 
-        /// <summary>
-        /// Specify the matching criteria with a filter definition
-        /// </summary>
-        /// <param name="filterDefinition">A filter definition</param>
-        public Update<T> Match(FilterDefinition<T> filterDefinition)
-        {
-            filter &= filterDefinition;
-            return this;
-        }
-
-        /// <summary>
-        /// Specify the matching criteria with a template
-        /// </summary>
-        /// <param name="template">A Template with a find query</param>
-        public Update<T> Match(Template template)
-        {
-            filter &= template.RenderToString();
-            return this;
-        }
-
-        /// <summary>
-        /// Specify a search term to find results from the text index of this particular collection.
-        /// <para>TIP: Make sure to define a text index with DB.Index&lt;T&gt;() before searching</para>
-        /// </summary>
-        /// <param name="searchType">The type of text matching to do</param>
-        /// <param name="searchTerm">The search term</param>
-        /// <param name="caseSensitive">Case sensitivity of the search (optional)</param>
-        /// <param name="diacriticSensitive">Diacritic sensitivity of the search (optional)</param>
-        /// <param name="language">The language for the search (optional)</param>
-        public Update<T> Match(Search searchType, string searchTerm, bool caseSensitive = false, bool diacriticSensitive = false, string language = null)
-        {
-            if (searchType == Search.Fuzzy)
-            {
-                searchTerm = searchTerm.ToDoubleMetaphoneHash();
-                caseSensitive = false;
-                diacriticSensitive = false;
-                language = null;
-            }
-
-            return Match(
-                f => f.Text(
-                    searchTerm,
-                    new TextSearchOptions
-                    {
-                        CaseSensitive = caseSensitive,
-                        DiacriticSensitive = diacriticSensitive,
-                        Language = language
-                    }));
-        }
-
-        /// <summary>
-        /// Specify criteria for matching entities based on GeoSpatial data (longitude &amp; latitude)
-        /// <para>TIP: Make sure to define a Geo2DSphere index with DB.Index&lt;T&gt;() before searching</para>
-        /// <para>Note: DB.FluentGeoNear() supports more advanced options</para>
-        /// </summary>
-        /// <param name="coordinatesProperty">The property where 2DCoordinates are stored</param>
-        /// <param name="nearCoordinates">The search point</param>
-        /// <param name="maxDistance">Maximum distance in meters from the search point</param>
-        /// <param name="minDistance">Minimum distance in meters from the search point</param>
-        public Update<T> Match(Expression<Func<T, object>> coordinatesProperty, Coordinates2D nearCoordinates, double? maxDistance = null, double? minDistance = null)
-        {
-            return Match(f => f.Near(coordinatesProperty, nearCoordinates.ToGeoJsonPoint(), maxDistance, minDistance));
-        }
-
-        /// <summary>
-        /// Specify the matching criteria with a JSON string
-        /// </summary>
-        /// <param name="jsonString">{ Title : 'The Power Of Now' }</param>
-        public Update<T> MatchString(string jsonString)
-        {
-            filter &= jsonString;
-            return this;
-        }
-
-        /// <summary>
-        /// Specify the matching criteria with an aggregation expression (i.e. $expr)
-        /// </summary>
-        /// <param name="expression">{ $gt: ['$Property1', '$Property2'] }</param>
-        public Update<T> MatchExpression(string expression)
-        {
-            filter &= "{$expr:" + expression + "}";
-            return this;
-        }
-
-        /// <summary>
-        /// Specify the matching criteria with a Template
-        /// </summary>
-        /// <param name="template">A Template object</param>
-        public Update<T> MatchExpression(Template template)
-        {
-            filter &= "{$expr:" + template.RenderToString() + "}";
-            return this;
-        }
 
         /// <summary>
         /// Specify the property and it's value to modify (use multiple times if needed)
@@ -263,7 +149,7 @@ public Update<T> Modify(Template template)
         /// <param name="entity">The entity instance to read the property values from</param>
         public Update<T> ModifyWith(T entity)
         {
-            if (Cache<T>.HasModifiedOn) ((IModifiedOn)entity).ModifiedOn = DateTime.UtcNow;
+            if (Cache<T>.Instance.HasModifiedOn) ((IModifiedOn)entity).ModifiedOn = DateTime.UtcNow;
             defs.AddRange(Logic.BuildUpdateDefs(entity));
             return this;
         }
@@ -275,7 +161,7 @@ public Update<T> ModifyWith(T entity)
         /// <param name="entity">The entity instance to read the corresponding values from</param>
         public Update<T> ModifyOnly(Expression<Func<T, object>> members, T entity)
         {
-            if (Cache<T>.HasModifiedOn) ((IModifiedOn)entity).ModifiedOn = DateTime.UtcNow;
+            if (Cache<T>.Instance.HasModifiedOn) ((IModifiedOn)entity).ModifiedOn = DateTime.UtcNow;
             defs.AddRange(Logic.BuildUpdateDefs(entity, members));
             return this;
         }
@@ -287,7 +173,7 @@ public Update<T> ModifyOnly(Expression<Func<T, object>> members, T entity)
         /// <param name="entity">The entity instance to read the corresponding values from</param>
         public Update<T> ModifyExcept(Expression<Func<T, object>> members, T entity)
         {
-            if (Cache<T>.HasModifiedOn) ((IModifiedOn)entity).ModifiedOn = DateTime.UtcNow;
+            if (Cache<T>.Instance.HasModifiedOn) ((IModifiedOn)entity).ModifiedOn = DateTime.UtcNow;
             defs.AddRange(Logic.BuildUpdateDefs(entity, members, excludeMode: true));
             return this;
         }
@@ -301,7 +187,7 @@ public Update<T> WithPipeline(Template template)
         {
             foreach (var stage in template.ToStages())
             {
-                stages.Add(stage);
+                _stages.Add(stage);
             }
 
             return this;
@@ -314,7 +200,7 @@ public Update<T> WithPipeline(Template template)
         /// <param name="stage">{ $set: { FullName: { $concat: ['$Name', ' ', '$Surname'] } } }</param>
         public Update<T> WithPipelineStage(string stage)
         {
-            stages.Add(stage);
+            _stages.Add(stage);
             return this;
         }
 
@@ -336,10 +222,10 @@ public Update<T> WithArrayFilter(string filter)
         {
             ArrayFilterDefinition<T> def = filter;
 
-            options.ArrayFilters =
-                options.ArrayFilters == null
+            _options.ArrayFilters =
+                _options.ArrayFilters == null
                 ? new[] { def }
-                : options.ArrayFilters.Concat(new[] { def });
+                : _options.ArrayFilters.Concat(new[] { def });
 
             return this;
         }
@@ -362,10 +248,10 @@ public Update<T> WithArrayFilters(Template template)
         {
             var defs = template.ToArrayFilters<T>();
 
-            options.ArrayFilters =
-                options.ArrayFilters == null
+            _options.ArrayFilters =
+                _options.ArrayFilters == null
                 ? defs
-                : options.ArrayFilters.Concat(defs);
+                : _options.ArrayFilters.Concat(defs);
 
             return this;
         }
@@ -377,40 +263,32 @@ public Update<T> WithArrayFilters(Template template)
         /// <param name="option">x => x.OptionName = OptionValue</param>
         public Update<T> Option(Action<UpdateOptions> option)
         {
-            option(options);
+            option(_options);
             return this;
         }
 
-        /// <summary>
-        /// Specify that this operation should ignore any global filters
-        /// </summary>
-        public Update<T> IgnoreGlobalFilters()
-        {
-            ignoreGlobalFilters = true;
-            return this;
-        }
+
 
         /// <summary>
         /// Queue up an update command for bulk execution later.
         /// </summary>
         public Update<T> AddToQueue()
         {
-            var mergedFilter = Logic.MergeWithGlobalFilter(ignoreGlobalFilters, globalFilters, filter);
+            var mergedFilter = MergedFilter;
             if (mergedFilter == Builders<T>.Filter.Empty) throw new ArgumentException("Please use Match() method first!");
             if (defs.Count == 0) throw new ArgumentException("Please use Modify() method first!");
-            if (Cache<T>.HasModifiedOn) Modify(b => b.CurrentDate(Cache<T>.ModifiedOnPropName));
-            SetTenantDbOnFileEntities(tenantPrefix);
-            onUpdateAction?.Invoke(this);
-            models.Add(new UpdateManyModel<T>(mergedFilter, Builders<T>.Update.Combine(defs))
+            if (Cache<T>.Instance.HasModifiedOn) Modify(b => b.CurrentDate(Cache<T>.Instance.ModifiedOnPropName));
+            _onUpdateAction?.Invoke(this);
+            _models.Add(new UpdateManyModel<T>(mergedFilter, Builders<T>.Update.Combine(defs))
             {
-                ArrayFilters = options.ArrayFilters,
-                Collation = options.Collation,
-                Hint = options.Hint,
-                IsUpsert = options.IsUpsert
+                ArrayFilters = _options.ArrayFilters,
+                Collation = _options.Collation,
+                Hint = _options.Hint,
+                IsUpsert = _options.IsUpsert
             });
-            filter = Builders<T>.Filter.Empty;
+            _filter = Builders<T>.Filter.Empty;
             defs.Clear();
-            options = new UpdateOptions();
+            _options = new UpdateOptions();
             return this;
         }
 
@@ -420,15 +298,15 @@ public Update<T> AddToQueue()
         /// <param name="cancellation">An optional cancellation token</param>
         public async Task<UpdateResult> ExecuteAsync(CancellationToken cancellation = default)
         {
-            if (models.Count > 0)
+            if (_models.Count > 0)
             {
                 var bulkWriteResult = await (
-                    session == null
-                    ? DB.Collection<T>(tenantPrefix).BulkWriteAsync(models, null, cancellation)
-                    : DB.Collection<T>(tenantPrefix).BulkWriteAsync(session, models, null, cancellation)
+                    this.Session() is not IClientSessionHandle session
+                    ? Collection.BulkWriteAsync(_models, null, cancellation)
+                    : Collection.BulkWriteAsync(session, _models, null, cancellation)
                     ).ConfigureAwait(false);
 
-                models.Clear();
+                _models.Clear();
 
                 if (!bulkWriteResult.IsAcknowledged)
                     return UpdateResult.Unacknowledged.Instance;
@@ -437,14 +315,14 @@ public async Task<UpdateResult> ExecuteAsync(CancellationToken cancellation = de
             }
             else
             {
-                var mergedFilter = Logic.MergeWithGlobalFilter(ignoreGlobalFilters, globalFilters, filter);
+                var mergedFilter = MergedFilter;
                 if (mergedFilter == Builders<T>.Filter.Empty) throw new ArgumentException("Please use Match() method first!");
                 if (defs.Count == 0) throw new ArgumentException("Please use a Modify() method first!");
-                if (stages.Count > 0) throw new ArgumentException("Regular updates and Pipeline updates cannot be used together!");
-                if (ShouldSetModDate()) Modify(b => b.CurrentDate(Cache<T>.ModifiedOnPropName));
-                SetTenantDbOnFileEntities(tenantPrefix);
-                onUpdateAction?.Invoke(this);
-                return await UpdateAsync(mergedFilter, Builders<T>.Update.Combine(defs), options, session, cancellation).ConfigureAwait(false);
+                if (_stages.Count > 0) throw new ArgumentException("Regular updates and Pipeline updates cannot be used together!");
+                if (ShouldSetModDate()) Modify(b => b.CurrentDate(Cache<T>.Instance.ModifiedOnPropName));
+
+                _onUpdateAction?.Invoke(this);
+                return await UpdateAsync(mergedFilter, Builders<T>.Update.Combine(defs), _options, this.Session(), cancellation).ConfigureAwait(false);
             }
         }
 
@@ -454,18 +332,17 @@ public async Task<UpdateResult> ExecuteAsync(CancellationToken cancellation = de
         /// <param name="cancellation">An optional cancellation token</param>
         public Task<UpdateResult> ExecutePipelineAsync(CancellationToken cancellation = default)
         {
-            var mergedFilter = Logic.MergeWithGlobalFilter(ignoreGlobalFilters, globalFilters, filter);
+            var mergedFilter = MergedFilter;
             if (mergedFilter == Builders<T>.Filter.Empty) throw new ArgumentException("Please use Match() method first!");
-            if (stages.Count == 0) throw new ArgumentException("Please use WithPipelineStage() method first!");
+            if (_stages.Count == 0) throw new ArgumentException("Please use WithPipelineStage() method first!");
             if (defs.Count > 0) throw new ArgumentException("Pipeline updates cannot be used together with regular updates!");
-            if (ShouldSetModDate()) WithPipelineStage($"{{ $set: {{ '{Cache<T>.ModifiedOnPropName}': new Date() }} }}");
-            SetTenantDbOnFileEntities(tenantPrefix);
+            if (ShouldSetModDate()) WithPipelineStage($"{{ $set: {{ '{Cache<T>.Instance.ModifiedOnPropName}': new Date() }} }}");
 
             return UpdateAsync(
                 mergedFilter,
-                Builders<T>.Update.Pipeline(stages.ToArray()),
-                options,
-                session,
+                Builders<T>.Update.Pipeline(_stages.ToArray()),
+                _options,
+                this.Session(),
                 cancellation);
         }
 
@@ -474,18 +351,18 @@ private bool ShouldSetModDate()
             //only set mod date by library if user hasn't done anything with the ModifiedOn property
 
             return
-                Cache<T>.HasModifiedOn &&
+                Cache<T>.Instance.HasModifiedOn &&
                 !defs.Any(d => d
                        .Render(BsonSerializer.SerializerRegistry.GetSerializer<T>(), BsonSerializer.SerializerRegistry)
                        .ToString()
-                       .Contains($"\"{Cache<T>.ModifiedOnPropName}\""));
+                       .Contains($"\"{Cache<T>.Instance.ModifiedOnPropName}\""));
         }
 
-        private Task<UpdateResult> UpdateAsync(FilterDefinition<T> filter, UpdateDefinition<T> definition, UpdateOptions options, IClientSessionHandle session = null, CancellationToken cancellation = default)
+        private Task<UpdateResult> UpdateAsync(FilterDefinition<T> filter, UpdateDefinition<T> definition, UpdateOptions options, IClientSessionHandle? session = null, CancellationToken cancellation = default)
         {
             return session == null
-                   ? DB.Collection<T>(tenantPrefix).UpdateManyAsync(filter, definition, options, cancellation)
-                   : DB.Collection<T>(tenantPrefix).UpdateManyAsync(session, filter, definition, options, cancellation);
+                   ? Collection.UpdateManyAsync(filter, definition, options, cancellation)
+                   : Collection.UpdateManyAsync(session, filter, definition, options, cancellation);
         }
     }
 }
diff --git a/MongoDB.Entities/Builders/UpdateAndGet.cs b/MongoDB.Entities/Builders/UpdateAndGet.cs
index fc42f67c4..3e3a0f814 100644
--- a/MongoDB.Entities/Builders/UpdateAndGet.cs
+++ b/MongoDB.Entities/Builders/UpdateAndGet.cs
@@ -19,7 +19,7 @@ public class UpdateAndGet<T> : UpdateAndGet<T, T> where T : IEntity
         internal UpdateAndGet(
             IClientSessionHandle session,
             Dictionary<Type, (object filterDef, bool prepend)> globalFilters,
-            Action<UpdateBase<T>> onUpdateAction,
+            Action<Update<T>> onUpdateAction,
             string tenantPrefix)
             : base(session, globalFilters, onUpdateAction, tenantPrefix) { }
     }
@@ -30,16 +30,11 @@ internal UpdateAndGet(
     /// </summary>
     /// <typeparam name="T">Any class that implements IEntity</typeparam>
     /// <typeparam name="TProjection">The type to project to</typeparam>
-    public class UpdateAndGet<T, TProjection> : UpdateBase<T> where T : IEntity
+    public class UpdateAndGet<T, TProjection> : UpdateBase<T, UpdateAndGet<T, TProjection>> where T : IEntity
     {
         private readonly List<PipelineStageDefinition<T, TProjection>> stages = new();
-        private FilterDefinition<T> filter = Builders<T>.Filter.Empty;
         private protected readonly FindOneAndUpdateOptions<T, TProjection> options = new() { ReturnDocument = ReturnDocument.After };
-        private readonly IClientSessionHandle session;
-        private readonly Dictionary<Type, (object filterDef, bool prepend)> globalFilters;
         private readonly Action<UpdateBase<T>> onUpdateAction;
-        private bool ignoreGlobalFilters;
-        private readonly string tenantPrefix;
 
         internal UpdateAndGet(
             IClientSessionHandle session,
diff --git a/MongoDB.Entities/Core/Cache.cs b/MongoDB.Entities/Core/Cache.cs
index 75119667c..77c9d1084 100644
--- a/MongoDB.Entities/Core/Cache.cs
+++ b/MongoDB.Entities/Core/Cache.cs
@@ -7,7 +7,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
-
+#nullable enable
 namespace MongoDB.Entities
 {
     internal abstract class Cache
@@ -46,6 +46,9 @@ internal string GetFullDbName(Type entityType, string tenantPrefix)
 
     internal class Cache<T> : Cache where T : IEntity
     {
+        private static Cache<T>? _instance;
+        public static Cache<T> Instance => _instance ??= new();
+
         public ConcurrentDictionary<string, Watcher<T>> Watchers { get; } = new();
         public bool HasCreatedOn { get; }
         public bool HasModifiedOn { get; }
@@ -59,10 +62,11 @@ internal class Cache<T> : Cache where T : IEntity
         //val: IMongoCollection<T>
         private readonly ConcurrentDictionary<string, IMongoCollection<T>> _cache = new();
         private readonly PropertyInfo[] _updatableProps;
-        private ProjectionDefinition<T> _requiredPropsProjection;
+        private ProjectionDefinition<T>? _requiredPropsProjection;
 
         public Cache()
         {
+            if (_instance == null) _instance = this;
             var type = typeof(T);
             var interfaces = type.GetInterfaces();
 
diff --git a/MongoDB.Entities/DBContext/DBContext.cs b/MongoDB.Entities/DBContext/DBContext.cs
index 1aea7d8b9..058410df4 100644
--- a/MongoDB.Entities/DBContext/DBContext.cs
+++ b/MongoDB.Entities/DBContext/DBContext.cs
@@ -265,10 +265,10 @@ protected void SetGlobalFilterForInterface<TInterface>(string jsonString, bool p
 
         private void ThrowIfModifiedByIsEmpty<T>() where T : IEntity
         {
-            if (Cache<T>().ModifiedByProp != null && ModifiedBy is null)
+            if (Cache<T>.Instance.ModifiedByProp != null && ModifiedBy is null)
             {
                 throw new InvalidOperationException(
-                    $"A value for [{Cache<T>.ModifiedByProp.Name}] must be specified when saving/updating entities of type [{Cache<T>.CollectionName}]");
+                    $"A value for [{Cache<T>.Instance.ModifiedByProp.Name}] must be specified when saving/updating entities of type [{Cache<T>.Instance.CollectionName}]");
             }
         }
 
diff --git a/MongoDB.Entities/Extensions/Entity.cs b/MongoDB.Entities/Extensions/Entity.cs
index bfb3dca39..6717ea969 100644
--- a/MongoDB.Entities/Extensions/Entity.cs
+++ b/MongoDB.Entities/Extensions/Entity.cs
@@ -170,21 +170,5 @@ public static Task<ulong> NextSequentialNumberAsync<T>(this T _, CancellationTok
         {
             return DB.NextSequentialNumberAsync<T>(cancellation, tenantPrefix);
         }
-
-        internal static void SetTenantPrefixOnFileEntity<T>(this T entity, string tenantPrefix) where T : IEntity
-        {
-            if (entity is FileEntity e)
-            {
-                e.TenantPrefix = tenantPrefix;
-            }
-        }
-
-        internal static void SetTenantDbOnFileEntities<T>(this IEnumerable<T> entities, string tenantPrefix) where T : IEntity
-        {
-            foreach (var entity in entities)
-            {
-                SetTenantPrefixOnFileEntity(entity, tenantPrefix);
-            }
-        }
     }
 }
diff --git a/MongoDB.Entities/MongoDB.Entities.csproj b/MongoDB.Entities/MongoDB.Entities.csproj
index a22fa9a34..a6002511a 100644
--- a/MongoDB.Entities/MongoDB.Entities.csproj
+++ b/MongoDB.Entities/MongoDB.Entities.csproj
@@ -1,47 +1,47 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
-  <PropertyGroup>
-    
-    <Version>21.0.0-alpha3</Version>
+	<PropertyGroup>
 
-    <PackageReleaseNotes>
-      - add support for db per tenant multi-tenancy
-      - remove previously deprecated NameAttribute
-      - remove ability to change default database during runtime
-      - upgrade dependencies
-    </PackageReleaseNotes>
+		<Version>21.0.0-alpha3</Version>
+		<Nullable>enable</Nullable>
+		<PackageReleaseNotes>
+			- add support for db per tenant multi-tenancy
+			- remove previously deprecated NameAttribute
+			- remove ability to change default database during runtime
+			- upgrade dependencies
+		</PackageReleaseNotes>
 
-    <TargetFramework>netstandard2.0</TargetFramework>
-    <RootNamespace>MongoDB.Entities</RootNamespace>
-    <AssemblyName>MongoDB.Entities</AssemblyName>
-    <Authors>Đĵ ΝιΓΞΗΛψΚ</Authors>
-    <Description>A data access library for MongoDB with an elegant api, LINQ support and built-in entity relationship management.</Description>
-    <PackageProjectUrl>https://mongodb-entities.com</PackageProjectUrl>
-    <Copyright>Đĵ ΝιΓΞΗΛψΚ</Copyright>
-    <PackageId>MongoDB.Entities</PackageId>
-    <Product>MongoDB.Entities</Product>
-    <RepositoryUrl>https://github.com/dj-nitehawk/MongoDB.Entities.git</RepositoryUrl>
-    <RepositoryType>git</RepositoryType>
-    <PackageLicenseExpression>MIT</PackageLicenseExpression>
-    <PackageIcon>icon.png</PackageIcon>
-    <PackageReadmeFile>README.md</PackageReadmeFile>
-    <PackageTags>mongodb mongodb-orm mongodb-repo mongodb-repository entities nosql orm linq netcore repository aspnetcore netcore2 netcore3 dotnetstandard database persistance dal repo</PackageTags>
-    <GenerateDocumentationFile>true</GenerateDocumentationFile>
-    <LangVersion>9.0</LangVersion>
-  </PropertyGroup>
+		<TargetFramework>netstandard2.0</TargetFramework>
+		<RootNamespace>MongoDB.Entities</RootNamespace>
+		<AssemblyName>MongoDB.Entities</AssemblyName>
+		<Authors>Đĵ ΝιΓΞΗΛψΚ</Authors>
+		<Description>A data access library for MongoDB with an elegant api, LINQ support and built-in entity relationship management.</Description>
+		<PackageProjectUrl>https://mongodb-entities.com</PackageProjectUrl>
+		<Copyright>Đĵ ΝιΓΞΗΛψΚ</Copyright>
+		<PackageId>MongoDB.Entities</PackageId>
+		<Product>MongoDB.Entities</Product>
+		<RepositoryUrl>https://github.com/dj-nitehawk/MongoDB.Entities.git</RepositoryUrl>
+		<RepositoryType>git</RepositoryType>
+		<PackageLicenseExpression>MIT</PackageLicenseExpression>
+		<PackageIcon>icon.png</PackageIcon>
+		<PackageReadmeFile>README.md</PackageReadmeFile>
+		<PackageTags>mongodb mongodb-orm mongodb-repo mongodb-repository entities nosql orm linq netcore repository aspnetcore netcore2 netcore3 dotnetstandard database persistance dal repo</PackageTags>
+		<GenerateDocumentationFile>true</GenerateDocumentationFile>
+		<LangVersion>9.0</LangVersion>
+	</PropertyGroup>
 
-  <PropertyGroup>
-    <NoWarn>CS1591,RCS1158</NoWarn>
-  </PropertyGroup>
+	<PropertyGroup>
+		<NoWarn>CS1591,RCS1158</NoWarn>
+	</PropertyGroup>
 
-  <ItemGroup>
-    <PackageReference Include="Microsoft.CSharp" Version="4.7.0" />
-    <PackageReference Include="MongoDB.Driver" Version="2.13.2" />
-  </ItemGroup>
+	<ItemGroup>
+		<PackageReference Include="Microsoft.CSharp" Version="4.7.0" />
+		<PackageReference Include="MongoDB.Driver" Version="2.13.2" />
+	</ItemGroup>
 
-  <ItemGroup>
-    <None Include="..\README.md" Pack="true" PackagePath="\" />
-    <None Include="..\Artwork\icon.png" Pack="true" PackagePath="\" />
-  </ItemGroup>
+	<ItemGroup>
+		<None Include="..\README.md" Pack="true" PackagePath="\" />
+		<None Include="..\Artwork\icon.png" Pack="true" PackagePath="\" />
+	</ItemGroup>
 
 </Project>
diff --git a/MongoDB.Entities/Relationships/Many.cs b/MongoDB.Entities/Relationships/Many.cs
index e3d5f9fa0..4b5f4a2da 100644
--- a/MongoDB.Entities/Relationships/Many.cs
+++ b/MongoDB.Entities/Relationships/Many.cs
@@ -38,6 +38,8 @@ public sealed partial class Many<TChild> : ManyBase where TChild : IEntity
         /// </summary>
         public IMongoCollection<JoinRecord> JoinCollection { get; private set; }
 
+        public string TargetCollectionName { get; set; }
+
         /// <summary>
         /// Get the number of children for a relationship
         /// </summary>

From 0ccb4e6b2426dac59b36879200920b914af39067 Mon Sep 17 00:00:00 2001
From: Ahmed Fwela <ahmednfwela@bdaya-dev.com>
Date: Fri, 5 Nov 2021 16:49:39 +0200
Subject: [PATCH 08/26] WIP update

---
 MongoDB.Entities/Builders/Update.cs | 107 +++++++++++++++-------------
 1 file changed, 58 insertions(+), 49 deletions(-)

diff --git a/MongoDB.Entities/Builders/Update.cs b/MongoDB.Entities/Builders/Update.cs
index 86bad7a9e..304429d8a 100644
--- a/MongoDB.Entities/Builders/Update.cs
+++ b/MongoDB.Entities/Builders/Update.cs
@@ -14,14 +14,19 @@ public class UpdateBase<T, TSelf> : FilterQueryBase<T, TSelf> where T : IEntity
         //note: this base class exists for facilating the OnBeforeUpdate custom hook of DBContext class
         //      there's no other purpose for this.
 
-        protected readonly List<UpdateDefinition<T>> defs = new();
+        protected readonly List<UpdateDefinition<T>> defs;
+        protected readonly Action<TSelf>? onUpdateAction;
 
-        internal UpdateBase(FilterQueryBase<T, TSelf> other) : base(other)
+        internal UpdateBase(UpdateBase<T, TSelf> other) : base(other)
         {
+            onUpdateAction = other.onUpdateAction;
+            defs = other.defs;
         }
-
-        internal UpdateBase(Dictionary<Type, (object filterDef, bool prepend)> globalFilters) : base(globalFilters)
+        private TSelf This => (TSelf)this;
+        internal UpdateBase(Dictionary<Type, (object filterDef, bool prepend)> globalFilters, Action<TSelf>? onUpdateAction, List<UpdateDefinition<T>>? defs) : base(globalFilters)
         {
+            this.onUpdateAction = onUpdateAction;
+            this.defs = defs ?? new();
         }
 
         /// <summary>
@@ -70,35 +75,6 @@ public void AddModification(Template template)
         //            Cache<T>.Instance.Collection(tenantPrefix).Database.DatabaseNamespace.DatabaseName));
         //    }
         //}
-    }
-
-    /// <summary>
-    /// Represents an update command
-    /// <para>TIP: Specify a filter first with the .Match(). Then set property values with .Modify() and finally call .Execute() to run the command.</para>
-    /// </summary>
-    /// <typeparam name="T">Any class that implements IEntity</typeparam>
-    public class Update<T> : UpdateBase<T, Update<T>>, ICollectionRelated<T> where T : IEntity
-    {
-        private readonly List<PipelineStageDefinition<T, T>> _stages = new();
-        private UpdateOptions _options = new();
-        private readonly List<UpdateManyModel<T>> _models = new();
-        private readonly Action<Update<T>> _onUpdateAction;
-
-        public DBContext Context { get; }
-        public IMongoCollection<T> Collection { get; }
-
-        internal Update(
-            DBContext context,
-            IMongoCollection<T> collection,
-            Dictionary<Type, (object filterDef, bool prepend)> globalFilters,
-            Action<Update<T>> onUpdateAction) :
-            base(globalFilters)
-        {
-            Context = context;
-            Collection = collection;
-            _onUpdateAction = onUpdateAction;
-        }
-
 
 
         /// <summary>
@@ -106,10 +82,10 @@ internal Update(
         /// </summary>
         /// <param name="property">x => x.Property</param>
         /// <param name="value">The value to set on the property</param>
-        public Update<T> Modify<TProp>(Expression<Func<T, TProp>> property, TProp value)
+        public TSelf Modify<TProp>(Expression<Func<T, TProp>> property, TProp value)
         {
             AddModification(property, value);
-            return this;
+            return This;
         }
 
         /// <summary>
@@ -117,41 +93,41 @@ public Update<T> Modify<TProp>(Expression<Func<T, TProp>> property, TProp value)
         /// </summary>
         /// <param name="operation">b => b.Inc(x => x.PropName, Value)</param>
         /// <returns></returns>
-        public Update<T> Modify(Func<UpdateDefinitionBuilder<T>, UpdateDefinition<T>> operation)
+        public TSelf Modify(Func<UpdateDefinitionBuilder<T>, UpdateDefinition<T>> operation)
         {
             AddModification(operation);
-            return this;
+            return This;
         }
 
         /// <summary>
         /// Specify an update (json string) to modify the Entities (use multiple times if needed)
         /// </summary>
         /// <param name="update">{ $set: { 'RootProp.$[x].SubProp' : 321 } }</param>
-        public Update<T> Modify(string update)
+        public TSelf Modify(string update)
         {
             AddModification(update);
-            return this;
+            return This;
         }
 
         /// <summary>
         /// Specify an update with a Template to modify the Entities (use multiple times if needed)
         /// </summary>
         /// <param name="template">A Template with a single update</param>
-        public Update<T> Modify(Template template)
+        public TSelf Modify(Template template)
         {
             AddModification(template.RenderToString());
-            return this;
+            return This;
         }
 
         /// <summary>
         /// Modify ALL properties with the values from the supplied entity instance.
         /// </summary>
         /// <param name="entity">The entity instance to read the property values from</param>
-        public Update<T> ModifyWith(T entity)
+        public TSelf ModifyWith(T entity)
         {
             if (Cache<T>.Instance.HasModifiedOn) ((IModifiedOn)entity).ModifiedOn = DateTime.UtcNow;
             defs.AddRange(Logic.BuildUpdateDefs(entity));
-            return this;
+            return This;
         }
 
         /// <summary>
@@ -159,11 +135,11 @@ public Update<T> ModifyWith(T entity)
         /// </summary>
         /// <param name="members">A new expression with the properties to include. Ex: <c>x => new { x.PropOne, x.PropTwo }</c></param>
         /// <param name="entity">The entity instance to read the corresponding values from</param>
-        public Update<T> ModifyOnly(Expression<Func<T, object>> members, T entity)
+        public TSelf ModifyOnly(Expression<Func<T, object>> members, T entity)
         {
             if (Cache<T>.Instance.HasModifiedOn) ((IModifiedOn)entity).ModifiedOn = DateTime.UtcNow;
             defs.AddRange(Logic.BuildUpdateDefs(entity, members));
-            return this;
+            return This;
         }
 
         /// <summary>
@@ -171,13 +147,46 @@ public Update<T> ModifyOnly(Expression<Func<T, object>> members, T entity)
         /// </summary>
         /// <param name="members">Supply a new expression with the properties to exclude. Ex: <c>x => new { x.Prop1, x.Prop2 }</c></param>
         /// <param name="entity">The entity instance to read the corresponding values from</param>
-        public Update<T> ModifyExcept(Expression<Func<T, object>> members, T entity)
+        public TSelf ModifyExcept(Expression<Func<T, object>> members, T entity)
         {
             if (Cache<T>.Instance.HasModifiedOn) ((IModifiedOn)entity).ModifiedOn = DateTime.UtcNow;
             defs.AddRange(Logic.BuildUpdateDefs(entity, members, excludeMode: true));
-            return this;
+            return This;
+        }
+    }
+
+    /// <summary>
+    /// Represents an update command
+    /// <para>TIP: Specify a filter first with the .Match(). Then set property values with .Modify() and finally call .Execute() to run the command.</para>
+    /// </summary>
+    /// <typeparam name="T">Any class that implements IEntity</typeparam>
+    public class Update<T> : UpdateBase<T, Update<T>>, ICollectionRelated<T> where T : IEntity
+    {
+        private readonly List<PipelineStageDefinition<T, T>> _stages = new();
+        private UpdateOptions _options = new();
+        private readonly List<UpdateManyModel<T>> _models = new();
+
+        internal Update(DBContext context, IMongoCollection<T> collection, UpdateBase<T, Update<T>> other) : base(other)
+        {
+            Context = context;
+            Collection = collection;
+        }
+
+        internal Update(DBContext context, IMongoCollection<T> collection, Dictionary<Type, (object filterDef, bool prepend)> globalFilters, Action<Update<T>>? onUpdateAction, List<UpdateDefinition<T>>? defs) : base(globalFilters, onUpdateAction, defs)
+        {
+            Context = context;
+            Collection = collection;
         }
 
+        public DBContext Context { get; }
+        public IMongoCollection<T> Collection { get; }
+
+
+
+
+
+
+
         /// <summary>
         /// Specify an update pipeline with multiple stages using a Template to modify the Entities.
         /// <para>NOTE: pipeline updates and regular updates cannot be used together.</para>
@@ -278,7 +287,7 @@ public Update<T> AddToQueue()
             if (mergedFilter == Builders<T>.Filter.Empty) throw new ArgumentException("Please use Match() method first!");
             if (defs.Count == 0) throw new ArgumentException("Please use Modify() method first!");
             if (Cache<T>.Instance.HasModifiedOn) Modify(b => b.CurrentDate(Cache<T>.Instance.ModifiedOnPropName));
-            _onUpdateAction?.Invoke(this);
+            onUpdateAction?.Invoke(this);
             _models.Add(new UpdateManyModel<T>(mergedFilter, Builders<T>.Update.Combine(defs))
             {
                 ArrayFilters = _options.ArrayFilters,
@@ -321,7 +330,7 @@ public async Task<UpdateResult> ExecuteAsync(CancellationToken cancellation = de
                 if (_stages.Count > 0) throw new ArgumentException("Regular updates and Pipeline updates cannot be used together!");
                 if (ShouldSetModDate()) Modify(b => b.CurrentDate(Cache<T>.Instance.ModifiedOnPropName));
 
-                _onUpdateAction?.Invoke(this);
+                onUpdateAction?.Invoke(this);
                 return await UpdateAsync(mergedFilter, Builders<T>.Update.Combine(defs), _options, this.Session(), cancellation).ConfigureAwait(false);
             }
         }

From da7e4d984c4fa56c6a5994677bcc509e24a2f364 Mon Sep 17 00:00:00 2001
From: Ahmed Fwela <ahmednfwela@bdaya-dev.com>
Date: Fri, 5 Nov 2021 17:16:01 +0200
Subject: [PATCH 09/26] WIP * Major refactoring * No more repeating code in
 builders * Multi-tenancy is per database now instead of per collection, which
 should be cleaner

---
 MongoDB.Entities/Builders/Update.cs           |   4 +-
 MongoDB.Entities/Builders/UpdateAndGet.cs     | 289 +++---------------
 MongoDB.Entities/Core/Cache.cs                |   1 -
 MongoDB.Entities/Core/DBContextOptions.cs     |   7 +-
 MongoDB.Entities/Core/MongoContextOptions.cs  |   4 +-
 .../DBContext/DBContext.Collection.cs         |   6 +-
 MongoDB.Entities/DBContext/DBContext.Find.cs  |   4 +-
 .../DBContext/DBContext.Update.cs             |  12 +-
 MongoDB.Entities/DBContext/DBContext.cs       |  30 +-
 MongoDB.Entities/Extensions/Entity.cs         |   2 +-
 .../MongoContext/MongoContext.IMongoClient.cs |   2 +-
 MongoDB.Entities/MongoContext/MongoContext.cs |   9 -
 MongoDB.Entities/Relationships/One.cs         |  87 +++---
 13 files changed, 130 insertions(+), 327 deletions(-)

diff --git a/MongoDB.Entities/Builders/Update.cs b/MongoDB.Entities/Builders/Update.cs
index 304429d8a..7fadaf296 100644
--- a/MongoDB.Entities/Builders/Update.cs
+++ b/MongoDB.Entities/Builders/Update.cs
@@ -23,7 +23,7 @@ internal UpdateBase(UpdateBase<T, TSelf> other) : base(other)
             defs = other.defs;
         }
         private TSelf This => (TSelf)this;
-        internal UpdateBase(Dictionary<Type, (object filterDef, bool prepend)> globalFilters, Action<TSelf>? onUpdateAction, List<UpdateDefinition<T>>? defs) : base(globalFilters)
+        internal UpdateBase(Dictionary<Type, (object filterDef, bool prepend)> globalFilters, Action<TSelf>? onUpdateAction = null, List<UpdateDefinition<T>>? defs = null) : base(globalFilters)
         {
             this.onUpdateAction = onUpdateAction;
             this.defs = defs ?? new();
@@ -172,7 +172,7 @@ internal Update(DBContext context, IMongoCollection<T> collection, UpdateBase<T,
             Collection = collection;
         }
 
-        internal Update(DBContext context, IMongoCollection<T> collection, Dictionary<Type, (object filterDef, bool prepend)> globalFilters, Action<Update<T>>? onUpdateAction, List<UpdateDefinition<T>>? defs) : base(globalFilters, onUpdateAction, defs)
+        internal Update(DBContext context, IMongoCollection<T> collection, Dictionary<Type, (object filterDef, bool prepend)> globalFilters, Action<Update<T>>? onUpdateAction, List<UpdateDefinition<T>>? defs = null) : base(globalFilters, onUpdateAction, defs)
         {
             Context = context;
             Collection = collection;
diff --git a/MongoDB.Entities/Builders/UpdateAndGet.cs b/MongoDB.Entities/Builders/UpdateAndGet.cs
index 3e3a0f814..54364c986 100644
--- a/MongoDB.Entities/Builders/UpdateAndGet.cs
+++ b/MongoDB.Entities/Builders/UpdateAndGet.cs
@@ -16,12 +16,13 @@ namespace MongoDB.Entities
     /// <typeparam name="T">Any class that implements IEntity</typeparam>
     public class UpdateAndGet<T> : UpdateAndGet<T, T> where T : IEntity
     {
-        internal UpdateAndGet(
-            IClientSessionHandle session,
-            Dictionary<Type, (object filterDef, bool prepend)> globalFilters,
-            Action<Update<T>> onUpdateAction,
-            string tenantPrefix)
-            : base(session, globalFilters, onUpdateAction, tenantPrefix) { }
+        internal UpdateAndGet(DBContext context, IMongoCollection<T> collection, UpdateBase<T, UpdateAndGet<T, T>> other) : base(context, collection, other)
+        {
+        }
+
+        internal UpdateAndGet(DBContext context, IMongoCollection<T> collection, Dictionary<Type, (object filterDef, bool prepend)> globalFilters, Action<UpdateAndGet<T, T>>? onUpdateAction, List<UpdateDefinition<T>>? defs) : base(context, collection, globalFilters, onUpdateAction, defs)
+        {
+        }
     }
 
     /// <summary>
@@ -30,221 +31,27 @@ internal UpdateAndGet(
     /// </summary>
     /// <typeparam name="T">Any class that implements IEntity</typeparam>
     /// <typeparam name="TProjection">The type to project to</typeparam>
-    public class UpdateAndGet<T, TProjection> : UpdateBase<T, UpdateAndGet<T, TProjection>> where T : IEntity
+    public class UpdateAndGet<T, TProjection> : UpdateBase<T, UpdateAndGet<T, TProjection>>, ICollectionRelated<T> where T : IEntity
     {
-        private readonly List<PipelineStageDefinition<T, TProjection>> stages = new();
-        private protected readonly FindOneAndUpdateOptions<T, TProjection> options = new() { ReturnDocument = ReturnDocument.After };
-        private readonly Action<UpdateBase<T>> onUpdateAction;
-
-        internal UpdateAndGet(
-            IClientSessionHandle session,
-            Dictionary<Type, (object filterDef, bool prepend)> globalFilters,
-            Action<UpdateBase<T>> onUpdateAction,
-            string tenantPrefix)
-        {
-            this.session = session;
-            this.globalFilters = globalFilters;
-            this.onUpdateAction = onUpdateAction;
-            this.tenantPrefix = tenantPrefix;
-        }
-
-        /// <summary>
-        /// Specify an IEntity ID as the matching criteria
-        /// </summary>
-        /// <param name="ID">A unique IEntity ID</param>
-        public UpdateAndGet<T, TProjection> MatchID(string ID)
-        {
-            return Match(f => f.Eq(t => t.ID, ID));
-        }
-
-        /// <summary>
-        /// Specify the matching criteria with a lambda expression
-        /// </summary>
-        /// <param name="expression">x => x.Property == Value</param>
-        public UpdateAndGet<T, TProjection> Match(Expression<Func<T, bool>> expression)
-        {
-            return Match(f => f.Where(expression));
-        }
-
-        /// <summary>
-        /// Specify the matching criteria with a filter expression
-        /// </summary>
-        /// <param name="filter">f => f.Eq(x => x.Prop, Value) &amp; f.Gt(x => x.Prop, Value)</param>
-        public UpdateAndGet<T, TProjection> Match(Func<FilterDefinitionBuilder<T>, FilterDefinition<T>> filter)
-        {
-            this.filter &= filter(Builders<T>.Filter);
-            return this;
-        }
-
-        /// <summary>
-        /// Specify the matching criteria with a filter definition
-        /// </summary>
-        /// <param name="filterDefinition">A filter definition</param>
-        public UpdateAndGet<T, TProjection> Match(FilterDefinition<T> filterDefinition)
-        {
-            filter &= filterDefinition;
-            return this;
-        }
+        private readonly List<PipelineStageDefinition<T, TProjection>> _stages = new();
+        private protected readonly FindOneAndUpdateOptions<T, TProjection> _options = new() { ReturnDocument = ReturnDocument.After };
 
-        /// <summary>
-        /// Specify the matching criteria with a template
-        /// </summary>
-        /// <param name="template">A Template with a find query</param>
-        public UpdateAndGet<T, TProjection> Match(Template template)
-        {
-            filter &= template.RenderToString();
-            return this;
-        }
+        public DBContext Context { get; }
+        public IMongoCollection<T> Collection { get; }
 
-        /// <summary>
-        /// Specify a search term to find results from the text index of this particular collection.
-        /// <para>TIP: Make sure to define a text index with DB.Index&lt;T&gt;() before searching</para>
-        /// </summary>
-        /// <param name="searchType">The type of text matching to do</param>
-        /// <param name="searchTerm">The search term</param>
-        /// <param name="caseSensitive">Case sensitivity of the search (optional)</param>
-        /// <param name="diacriticSensitive">Diacritic sensitivity of the search (optional)</param>
-        /// <param name="language">The language for the search (optional)</param>
-        public UpdateAndGet<T, TProjection> Match(Search searchType, string searchTerm, bool caseSensitive = false, bool diacriticSensitive = false, string language = null)
+        internal UpdateAndGet(DBContext context, IMongoCollection<T> collection, UpdateBase<T, UpdateAndGet<T, TProjection>> other) : base(other)
         {
-            if (searchType == Search.Fuzzy)
-            {
-                searchTerm = searchTerm.ToDoubleMetaphoneHash();
-                caseSensitive = false;
-                diacriticSensitive = false;
-                language = null;
-            }
-
-            return Match(
-                f => f.Text(
-                    searchTerm,
-                    new TextSearchOptions
-                    {
-                        CaseSensitive = caseSensitive,
-                        DiacriticSensitive = diacriticSensitive,
-                        Language = language
-                    }));
+            Context = context;
+            Collection = collection;
         }
 
-        /// <summary>
-        /// Specify criteria for matching entities based on GeoSpatial data (longitude &amp; latitude)
-        /// <para>TIP: Make sure to define a Geo2DSphere index with DB.Index&lt;T&gt;() before searching</para>
-        /// <para>Note: DB.FluentGeoNear() supports more advanced options</para>
-        /// </summary>
-        /// <param name="coordinatesProperty">The property where 2DCoordinates are stored</param>
-        /// <param name="nearCoordinates">The search point</param>
-        /// <param name="maxDistance">Maximum distance in meters from the search point</param>
-        /// <param name="minDistance">Minimum distance in meters from the search point</param>
-        public UpdateAndGet<T, TProjection> Match(Expression<Func<T, object>> coordinatesProperty, Coordinates2D nearCoordinates, double? maxDistance = null, double? minDistance = null)
+        internal UpdateAndGet(DBContext context, IMongoCollection<T> collection, Dictionary<Type, (object filterDef, bool prepend)> globalFilters, Action<UpdateAndGet<T, TProjection>>? onUpdateAction = null, List<UpdateDefinition<T>>? defs = null) : base(globalFilters, onUpdateAction, defs)
         {
-            return Match(f => f.Near(coordinatesProperty, nearCoordinates.ToGeoJsonPoint(), maxDistance, minDistance));
+            Context = context;
+            Collection = collection;
         }
 
-        /// <summary>
-        /// Specify the matching criteria with a JSON string
-        /// </summary>
-        /// <param name="jsonString">{ Title : 'The Power Of Now' }</param>
-        public UpdateAndGet<T, TProjection> MatchString(string jsonString)
-        {
-            filter &= jsonString;
-            return this;
-        }
 
-        /// <summary>
-        /// Specify the matching criteria with an aggregation expression (i.e. $expr)
-        /// </summary>
-        /// <param name="expression">{ $gt: ['$Property1', '$Property2'] }</param>
-        public UpdateAndGet<T, TProjection> MatchExpression(string expression)
-        {
-            filter &= "{$expr:" + expression + "}";
-            return this;
-        }
-
-        /// <summary>
-        /// Specify the matching criteria with a Template
-        /// </summary>
-        /// <param name="template">A Template object</param>
-        public UpdateAndGet<T, TProjection> MatchExpression(Template template)
-        {
-            filter &= "{$expr:" + template.RenderToString() + "}";
-            return this;
-        }
-
-        /// <summary>
-        /// Specify the property and it's value to modify (use multiple times if needed)
-        /// </summary>
-        /// <param name="property">x => x.Property</param>
-        /// <param name="value">The value to set on the property</param>
-        public UpdateAndGet<T, TProjection> Modify<TProp>(Expression<Func<T, TProp>> property, TProp value)
-        {
-            AddModification(property, value);
-            return this;
-        }
-
-        /// <summary>
-        /// Specify the update definition builder operation to modify the Entities (use multiple times if needed)
-        /// </summary>
-        /// <param name="operation">b => b.Inc(x => x.PropName, Value)</param>
-        public UpdateAndGet<T, TProjection> Modify(Func<UpdateDefinitionBuilder<T>, UpdateDefinition<T>> operation)
-        {
-            AddModification(operation);
-            return this;
-        }
-
-        /// <summary>
-        /// Specify an update (json string) to modify the Entities (use multiple times if needed)
-        /// </summary>
-        /// <param name="update">{ $set: { 'RootProp.$[x].SubProp' : 321 } }</param>
-        public UpdateAndGet<T, TProjection> Modify(string update)
-        {
-            AddModification(update);
-            return this;
-        }
-
-        /// <summary>
-        /// Specify an update with a Template to modify the Entities (use multiple times if needed)
-        /// </summary>
-        /// <param name="template">A Template with a single update</param>
-        public UpdateAndGet<T, TProjection> Modify(Template template)
-        {
-            AddModification(template.RenderToString());
-            return this;
-        }
-
-        /// <summary>
-        /// Modify ALL properties with the values from the supplied entity instance.
-        /// </summary>
-        /// <param name="entity">The entity instance to read the property values from</param>
-        public UpdateAndGet<T, TProjection> ModifyWith(T entity)
-        {
-            if (Cache<T>.HasModifiedOn) ((IModifiedOn)entity).ModifiedOn = DateTime.UtcNow;
-            defs.AddRange(Logic.BuildUpdateDefs(entity));
-            return this;
-        }
-
-        /// <summary>
-        /// Modify ONLY the specified properties with the values from a given entity instance.
-        /// </summary>
-        /// <param name="members">A new expression with the properties to include. Ex: <c>x => new { x.PropOne, x.PropTwo }</c></param>
-        /// <param name="entity">The entity instance to read the corresponding values from</param>
-        public UpdateAndGet<T, TProjection> ModifyOnly(Expression<Func<T, object>> members, T entity)
-        {
-            if (Cache<T>.HasModifiedOn) ((IModifiedOn)entity).ModifiedOn = DateTime.UtcNow;
-            defs.AddRange(Logic.BuildUpdateDefs(entity, members));
-            return this;
-        }
-
-        /// <summary>
-        /// Modify all EXCEPT the specified properties with the values from a given entity instance.
-        /// </summary>
-        /// <param name="members">Supply a new expression with the properties to exclude. Ex: <c>x => new { x.Prop1, x.Prop2 }</c></param>
-        /// <param name="entity">The entity instance to read the corresponding values from</param>
-        public UpdateAndGet<T, TProjection> ModifyExcept(Expression<Func<T, object>> members, T entity)
-        {
-            if (Cache<T>.HasModifiedOn) ((IModifiedOn)entity).ModifiedOn = DateTime.UtcNow;
-            defs.AddRange(Logic.BuildUpdateDefs(entity, members, excludeMode: true));
-            return this;
-        }
 
         /// <summary>
         /// Specify an update pipeline with multiple stages using a Template to modify the Entities.
@@ -255,7 +62,7 @@ public UpdateAndGet<T, TProjection> WithPipeline(Template template)
         {
             foreach (var stage in template.ToStages())
             {
-                stages.Add(stage);
+                _stages.Add(stage);
             }
 
             return this;
@@ -268,7 +75,7 @@ public UpdateAndGet<T, TProjection> WithPipeline(Template template)
         /// <param name="stage">{ $set: { FullName: { $concat: ['$Name', ' ', '$Surname'] } } }</param>
         public UpdateAndGet<T, TProjection> WithPipelineStage(string stage)
         {
-            stages.Add(stage);
+            _stages.Add(stage);
             return this;
         }
 
@@ -290,10 +97,10 @@ public UpdateAndGet<T, TProjection> WithArrayFilter(string filter)
         {
             ArrayFilterDefinition<T> def = filter;
 
-            options.ArrayFilters =
-                options.ArrayFilters == null
+            _options.ArrayFilters =
+                _options.ArrayFilters == null
                 ? new[] { def }
-                : options.ArrayFilters.Concat(new[] { def });
+                : _options.ArrayFilters.Concat(new[] { def });
 
             return this;
         }
@@ -316,10 +123,10 @@ public UpdateAndGet<T, TProjection> WithArrayFilters(Template template)
         {
             var defs = template.ToArrayFilters<T>();
 
-            options.ArrayFilters =
-                options.ArrayFilters == null
+            _options.ArrayFilters =
+                _options.ArrayFilters == null
                 ? defs
-                : options.ArrayFilters.Concat(defs);
+                : _options.ArrayFilters.Concat(defs);
 
             return this;
         }
@@ -331,7 +138,7 @@ public UpdateAndGet<T, TProjection> WithArrayFilters(Template template)
         /// <param name="option">x => x.OptionName = OptionValue</param>
         public UpdateAndGet<T, TProjection> Option(Action<FindOneAndUpdateOptions<T, TProjection>> option)
         {
-            option(options);
+            option(_options);
             return this;
         }
 
@@ -350,7 +157,7 @@ public UpdateAndGet<T, TProjection> Project(Expression<Func<T, TProjection>> exp
         /// <param name="projection">p => p.Include("Prop1").Exclude("Prop2")</param>
         public UpdateAndGet<T, TProjection> Project(Func<ProjectionDefinitionBuilder<T>, ProjectionDefinition<T, TProjection>> projection)
         {
-            options.Projection = projection(Builders<T>.Projection);
+            _options.Projection = projection(Builders<T>.Projection);
             return this;
         }
 
@@ -363,16 +170,7 @@ public UpdateAndGet<T, TProjection> IncludeRequiredProps()
             if (typeof(T) != typeof(TProjection))
                 throw new InvalidOperationException("IncludeRequiredProps() cannot be used when projecting to a different type.");
 
-            options.Projection = Cache<T>.CombineWithRequiredProps(options.Projection);
-            return this;
-        }
-
-        /// <summary>
-        /// Specify that this operation should ignore any global filters
-        /// </summary>
-        public UpdateAndGet<T, TProjection> IgnoreGlobalFilters()
-        {
-            ignoreGlobalFilters = true;
+            _options.Projection = Cache<T>.Instance.CombineWithRequiredProps(_options.Projection);
             return this;
         }
 
@@ -382,14 +180,13 @@ public UpdateAndGet<T, TProjection> IgnoreGlobalFilters()
         /// <param name="cancellation">An optional cancellation token</param>
         public async Task<TProjection> ExecuteAsync(CancellationToken cancellation = default)
         {
-            var mergedFilter = Logic.MergeWithGlobalFilter(ignoreGlobalFilters, globalFilters, filter);
+            var mergedFilter = MergedFilter;
             if (mergedFilter == Builders<T>.Filter.Empty) throw new ArgumentException("Please use Match() method first!");
             if (defs.Count == 0) throw new ArgumentException("Please use Modify() method first!");
-            if (stages.Count > 0) throw new ArgumentException("Regular updates and Pipeline updates cannot be used together!");
-            if (ShouldSetModDate()) Modify(b => b.CurrentDate(Cache<T>.ModifiedOnPropName));
-            SetTenantDbOnFileEntities(tenantPrefix);
+            if (_stages.Count > 0) throw new ArgumentException("Regular updates and Pipeline updates cannot be used together!");
+            if (ShouldSetModDate()) Modify(b => b.CurrentDate(Cache<T>.Instance.ModifiedOnPropName));
             onUpdateAction?.Invoke(this);
-            return await UpdateAndGetAsync(mergedFilter, Builders<T>.Update.Combine(defs), options, session, cancellation).ConfigureAwait(false);
+            return await UpdateAndGetAsync(mergedFilter, Builders<T>.Update.Combine(defs), _options, this.Session(), cancellation).ConfigureAwait(false);
         }
 
         /// <summary>
@@ -398,14 +195,14 @@ public async Task<TProjection> ExecuteAsync(CancellationToken cancellation = def
         /// <param name="cancellation">An optional cancellation token</param>
         public Task<TProjection> ExecutePipelineAsync(CancellationToken cancellation = default)
         {
-            var mergedFilter = Logic.MergeWithGlobalFilter(ignoreGlobalFilters, globalFilters, filter);
+            var mergedFilter = MergedFilter;
             if (mergedFilter == Builders<T>.Filter.Empty) throw new ArgumentException("Please use Match() method first!");
-            if (stages.Count == 0) throw new ArgumentException("Please use WithPipelineStage() method first!");
+            if (_stages.Count == 0) throw new ArgumentException("Please use WithPipelineStage() method first!");
             if (defs.Count > 0) throw new ArgumentException("Pipeline updates cannot be used together with regular updates!");
-            if (ShouldSetModDate()) WithPipelineStage($"{{ $set: {{ '{Cache<T>.ModifiedOnPropName}': new Date() }} }}");
-            SetTenantDbOnFileEntities(tenantPrefix);
+            if (ShouldSetModDate()) WithPipelineStage($"{{ $set: {{ '{Cache<T>.Instance.ModifiedOnPropName}': new Date() }} }}");
+
 
-            return UpdateAndGetAsync(mergedFilter, Builders<T>.Update.Pipeline(stages.ToArray()), options, session, cancellation);
+            return UpdateAndGetAsync(mergedFilter, Builders<T>.Update.Pipeline(_stages.ToArray()), _options, this.Session(), cancellation);
         }
 
         private bool ShouldSetModDate()
@@ -413,18 +210,18 @@ private bool ShouldSetModDate()
             //only set mod date by library if user hasn't done anything with the ModifiedOn property
 
             return
-                Cache<T>.HasModifiedOn &&
+                Cache<T>.Instance.HasModifiedOn &&
                 !defs.Any(d => d
                        .Render(BsonSerializer.SerializerRegistry.GetSerializer<T>(), BsonSerializer.SerializerRegistry)
                        .ToString()
-                       .Contains($"\"{Cache<T>.ModifiedOnPropName}\""));
+                       .Contains($"\"{Cache<T>.Instance.ModifiedOnPropName}\""));
         }
 
-        private Task<TProjection> UpdateAndGetAsync(FilterDefinition<T> filter, UpdateDefinition<T> definition, FindOneAndUpdateOptions<T, TProjection> options, IClientSessionHandle session = null, CancellationToken cancellation = default)
+        private Task<TProjection> UpdateAndGetAsync(FilterDefinition<T> filter, UpdateDefinition<T> definition, FindOneAndUpdateOptions<T, TProjection> options, IClientSessionHandle? session = null, CancellationToken cancellation = default)
         {
             return session == null
-                ? DB.Collection<T>(tenantPrefix).FindOneAndUpdateAsync(filter, definition, options, cancellation)
-                : DB.Collection<T>(tenantPrefix).FindOneAndUpdateAsync(session, filter, definition, options, cancellation);
+                ? Collection.FindOneAndUpdateAsync(filter, definition, options, cancellation)
+                : Collection.FindOneAndUpdateAsync(session, filter, definition, options, cancellation);
         }
     }
 }
diff --git a/MongoDB.Entities/Core/Cache.cs b/MongoDB.Entities/Core/Cache.cs
index 77c9d1084..704b71802 100644
--- a/MongoDB.Entities/Core/Cache.cs
+++ b/MongoDB.Entities/Core/Cache.cs
@@ -66,7 +66,6 @@ internal class Cache<T> : Cache where T : IEntity
 
         public Cache()
         {
-            if (_instance == null) _instance = this;
             var type = typeof(T);
             var interfaces = type.GetInterfaces();
 
diff --git a/MongoDB.Entities/Core/DBContextOptions.cs b/MongoDB.Entities/Core/DBContextOptions.cs
index a0571e7ee..db734ce92 100644
--- a/MongoDB.Entities/Core/DBContextOptions.cs
+++ b/MongoDB.Entities/Core/DBContextOptions.cs
@@ -6,12 +6,7 @@ namespace MongoDB.Entities
 {
     public class DBContextOptions
     {
-        public DBContextOptions(string? tenantId = null)
-        {
-            TenantId = tenantId;
-        }
-
-        public string? TenantId { get; set; }
+        
         
     }
 }
diff --git a/MongoDB.Entities/Core/MongoContextOptions.cs b/MongoDB.Entities/Core/MongoContextOptions.cs
index 8403c13eb..503267109 100644
--- a/MongoDB.Entities/Core/MongoContextOptions.cs
+++ b/MongoDB.Entities/Core/MongoContextOptions.cs
@@ -9,14 +9,16 @@ namespace MongoDB.Entities
 {
     public class MongoContextOptions
     {
-        public MongoContextOptions(ModifiedBy? modifiedBy = null)
+        public MongoContextOptions(ModifiedBy? modifiedBy = null, string? tenantId = null)
         {
             ModifiedBy = modifiedBy;
+            TenantId = tenantId;
         }
 
         /// <summary>
         /// The value of this property will be automatically set on entities when saving/updating if the entity has a ModifiedBy property
         /// </summary>
         public ModifiedBy? ModifiedBy { get; set; }
+        public string? TenantId { get; set; }
     }
 }
diff --git a/MongoDB.Entities/DBContext/DBContext.Collection.cs b/MongoDB.Entities/DBContext/DBContext.Collection.cs
index 7399448f3..93a106202 100644
--- a/MongoDB.Entities/DBContext/DBContext.Collection.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Collection.cs
@@ -19,8 +19,8 @@ public Task CreateCollectionAsync<T>(Action<CreateCollectionOptions<T>> options,
             var opts = new CreateCollectionOptions<T>();
             options(opts);
             return Session == null
-                  ? Database.CreateCollectionAsync(Cache<T>.CollectionName, opts, cancellation)
-                  : Database.CreateCollectionAsync(Session, Cache<T>.CollectionName, opts, cancellation);
+                  ? Database.CreateCollectionAsync(Cache<T>().CollectionName, opts, cancellation)
+                  : Database.CreateCollectionAsync(Session, Cache<T>().CollectionName, opts, cancellation);
 
         }
 
@@ -33,7 +33,7 @@ public async Task DropCollectionAsync<T>() where T : IEntity
         {
             var tasks = new List<Task>();
             var db = Database;
-            var collName = Cache<T>.CollectionName;
+            var collName = Cache<T>().CollectionName;
             var options = new ListCollectionNamesOptions
             {
                 Filter = "{$and:[{name:/~/},{name:/" + collName + "/}]}"
diff --git a/MongoDB.Entities/DBContext/DBContext.Find.cs b/MongoDB.Entities/DBContext/DBContext.Find.cs
index 7a1f9fe35..250ac7086 100644
--- a/MongoDB.Entities/DBContext/DBContext.Find.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Find.cs
@@ -8,7 +8,7 @@ public partial class DBContext
         /// <typeparam name="T">The type of entity</typeparam>
         public Find<T> Find<T>() where T : IEntity
         {
-            return new Find<T>(Session, _globalFilters, tenantPrefix);
+            return new Find<T>(this, CollectionFor<T>(), _globalFilters);
         }
 
         /// <summary>
@@ -18,7 +18,7 @@ public Find<T> Find<T>() where T : IEntity
         /// <typeparam name="TProjection">The type of the end result</typeparam>
         public Find<T, TProjection> Find<T, TProjection>() where T : IEntity
         {
-            return new Find<T, TProjection>(Session, _globalFilters, tenantPrefix);
+            return new Find<T, TProjection>(this, CollectionFor<T>(), _globalFilters);
         }
     }
 }
diff --git a/MongoDB.Entities/DBContext/DBContext.Update.cs b/MongoDB.Entities/DBContext/DBContext.Update.cs
index e7ef641d0..928b0fe87 100644
--- a/MongoDB.Entities/DBContext/DBContext.Update.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Update.cs
@@ -8,11 +8,11 @@ public partial class DBContext
         /// <typeparam name="T">The type of entity</typeparam>
         public Update<T> Update<T>() where T : IEntity
         {
-            var cmd = new Update<T>(Session, _globalFilters, OnBeforeUpdate<T>(), tenantPrefix);
-            if (Cache<T>.ModifiedByProp != null)
+            var cmd = new Update<T>(this, CollectionFor<T>(), _globalFilters, OnBeforeUpdate<T, Update<T>>());
+            if (Cache<T>().ModifiedByProp != null)
             {
                 ThrowIfModifiedByIsEmpty<T>();
-                cmd.Modify(b => b.Set(Cache<T>.ModifiedByProp.Name, ModifiedBy));
+                cmd.Modify(b => b.Set(Cache<T>().ModifiedByProp.Name, ModifiedBy));
             }
             return cmd;
         }
@@ -33,11 +33,11 @@ public UpdateAndGet<T, T> UpdateAndGet<T>() where T : IEntity
         /// <typeparam name="TProjection">The type of the end result</typeparam>
         public UpdateAndGet<T, TProjection> UpdateAndGet<T, TProjection>() where T : IEntity
         {
-            var cmd = new UpdateAndGet<T, TProjection>(Session, _globalFilters, OnBeforeUpdate<T>(), tenantPrefix);
-            if (Cache<T>.ModifiedByProp != null)
+            var cmd = new UpdateAndGet<T, TProjection>(this, CollectionFor<T>(), _globalFilters, OnBeforeUpdate<T, UpdateAndGet<T, TProjection>>());
+            if (Cache<T>().ModifiedByProp != null)
             {
                 ThrowIfModifiedByIsEmpty<T>();
-                cmd.Modify(b => b.Set(Cache<T>.ModifiedByProp.Name, ModifiedBy));
+                cmd.Modify(b => b.Set(Cache<T>().ModifiedByProp.Name, ModifiedBy));
             }
             return cmd;
         }
diff --git a/MongoDB.Entities/DBContext/DBContext.cs b/MongoDB.Entities/DBContext/DBContext.cs
index 058410df4..2e9646370 100644
--- a/MongoDB.Entities/DBContext/DBContext.cs
+++ b/MongoDB.Entities/DBContext/DBContext.cs
@@ -1,6 +1,7 @@
 using MongoDB.Bson.Serialization;
 using MongoDB.Driver;
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
 using System.Linq.Expressions;
@@ -67,8 +68,8 @@ public DBContext(MongoContext mongoContext, IMongoDatabase database, DBContextOp
         public DBContext(MongoContext mongoContext, string database, MongoDatabaseSettings? settings = null, DBContextOptions? options = null)
         {
             MongoContext = mongoContext;
-            Database = mongoContext.GetDatabase(database, settings);
             Options = options ?? new();
+            Database = mongoContext.GetDatabase((mongoContext.Options.TenantId ?? "") + database, settings);
         }
 
         /// <summary>
@@ -94,8 +95,8 @@ public DBContext(string database, string host = "127.0.0.1", int port = 27017, M
                 {
                     ModifiedBy = modifiedBy
                 });
-            Database = MongoContext.GetDatabase(database);
             Options = new();
+            Database = MongoContext.GetDatabase((MongoContext.Options.TenantId ?? "") + database);
         }
 
         /// <summary>
@@ -116,8 +117,8 @@ public DBContext(string database, MongoClientSettings settings, ModifiedBy? modi
                {
                    ModifiedBy = modifiedBy
                });
-            Database = MongoContext.GetDatabase(database);
             Options = new();
+            Database = MongoContext.GetDatabase((MongoContext.Options.TenantId ?? "") + database);
         }
 
 
@@ -148,7 +149,8 @@ public DBContext(ModifiedBy? modifiedBy = null) : this("default", modifiedBy: mo
         /// This event hook will be triggered right before an update/replace command is executed
         /// </summary>
         /// <typeparam name="T">Any entity that implements IEntity</typeparam>
-        protected virtual Action<UpdateBase<T>>? OnBeforeUpdate<T>() where T : IEntity
+        /// <typeparam name="TSelf">Any entity that implements IEntity</typeparam>
+        protected virtual Action<UpdateBase<T, TSelf>>? OnBeforeUpdate<T, TSelf>() where T : IEntity where TSelf : UpdateBase<T, TSelf>
         {
             return null;
         }
@@ -265,10 +267,10 @@ protected void SetGlobalFilterForInterface<TInterface>(string jsonString, bool p
 
         private void ThrowIfModifiedByIsEmpty<T>() where T : IEntity
         {
-            if (Cache<T>.Instance.ModifiedByProp != null && ModifiedBy is null)
+            if (Cache<T>().ModifiedByProp != null && ModifiedBy is null)
             {
                 throw new InvalidOperationException(
-                    $"A value for [{Cache<T>.Instance.ModifiedByProp.Name}] must be specified when saving/updating entities of type [{Cache<T>.Instance.CollectionName}]");
+                    $"A value for [{Cache<T>().ModifiedByProp.Name}] must be specified when saving/updating entities of type [{Cache<T>().CollectionName}]");
             }
         }
 
@@ -278,5 +280,21 @@ private void AddFilter(Type type, (object filterDef, bool prepend) filter)
 
             _globalFilters[type] = filter;
         }
+
+
+        private readonly ConcurrentDictionary<Type, Cache> _cache = new();
+        internal Cache<T> Cache<T>() where T : IEntity
+        {
+            if (!_cache.TryGetValue(typeof(T), out var c))
+            {
+                c = new Cache<T>();
+            }
+            return (Cache<T>)c;
+        }
+
+        public IMongoCollection<T> CollectionFor<T>() where T : IEntity
+        {
+            return Database.GetCollection<T>(Cache<T>().CollectionName);
+        }
     }
 }
diff --git a/MongoDB.Entities/Extensions/Entity.cs b/MongoDB.Entities/Extensions/Entity.cs
index 6717ea969..80e0bf4a6 100644
--- a/MongoDB.Entities/Extensions/Entity.cs
+++ b/MongoDB.Entities/Extensions/Entity.cs
@@ -76,7 +76,7 @@ public static string FullPath<T>(this Expression<Func<T, object>> expression)
         /// <summary>
         /// An IQueryable collection of sibling Entities.
         /// </summary>
-        public static IMongoQueryable<T> Queryable<T>(this T _, AggregateOptions options = null, string tenantPrefix = null) where T : IEntity
+        public static IMongoQueryable<T> Queryable<T>(this T _, AggregateOptions? options = null, string tenantPrefix = null) where T : IEntity
         {
             return DB.Queryable<T>(options, tenantPrefix: tenantPrefix);
         }
diff --git a/MongoDB.Entities/MongoContext/MongoContext.IMongoClient.cs b/MongoDB.Entities/MongoContext/MongoContext.IMongoClient.cs
index 90abdd0c7..fd475a6ec 100644
--- a/MongoDB.Entities/MongoContext/MongoContext.IMongoClient.cs
+++ b/MongoDB.Entities/MongoContext/MongoContext.IMongoClient.cs
@@ -36,7 +36,7 @@ Task IMongoClient.DropDatabaseAsync(IClientSessionHandle session, string name, C
             return Client.DropDatabaseAsync(session, name, cancellationToken);
         }
 
-        public IMongoDatabase GetDatabase(string name, MongoDatabaseSettings settings = null)
+        public IMongoDatabase GetDatabase(string name, MongoDatabaseSettings? settings = null)
         {
             return Client.GetDatabase(name, settings);
         }
diff --git a/MongoDB.Entities/MongoContext/MongoContext.cs b/MongoDB.Entities/MongoContext/MongoContext.cs
index a10bd78c2..3e0253446 100644
--- a/MongoDB.Entities/MongoContext/MongoContext.cs
+++ b/MongoDB.Entities/MongoContext/MongoContext.cs
@@ -44,15 +44,6 @@ public async Task<List<string>> AllDatabaseNamesAsync()
         private Type[]? _allEntitiyTypes;
         public Type[] AllEntitiyTypes => _allEntitiyTypes ??= GetAllEntityTypes();
 
-        private readonly ConcurrentDictionary<Type, Cache> _cache = new();
-        internal Cache<T> Cache<T>() where T : IEntity
-        {
-            if (!_cache.TryGetValue(typeof(T), out var c))
-            {
-                c = new Cache<T>();
-            }
-            return (Cache<T>)c;
-        }
 
         private static Type[] GetAllEntityTypes()
         {
diff --git a/MongoDB.Entities/Relationships/One.cs b/MongoDB.Entities/Relationships/One.cs
index aae1a4845..e6d2f6220 100644
--- a/MongoDB.Entities/Relationships/One.cs
+++ b/MongoDB.Entities/Relationships/One.cs
@@ -50,50 +50,51 @@ public static implicit operator One<T>(T entity)
             return new One<T>(entity);
         }
 
-        /// <summary>
-        /// Fetches the actual entity this reference represents from the database.
-        /// </summary>
-        /// <param name="session">An optional session</param>
-        /// <param name="cancellation">An optional cancellation token</param>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        /// <returns>A Task containing the actual entity</returns>
-        public Task<T> ToEntityAsync(IClientSessionHandle session = null, CancellationToken cancellation = default, string tenantPrefix = null)
-        {
-            return new Find<T>(session, null, tenantPrefix).OneAsync(ID, cancellation);
-        }
+        //TODO: revamp One/Many api
+        ///// <summary>
+        ///// Fetches the actual entity this reference represents from the database.
+        ///// </summary>
+        ///// <param name="session">An optional session</param>
+        ///// <param name="cancellation">An optional cancellation token</param>
+        ///// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
+        ///// <returns>A Task containing the actual entity</returns>
+        //public Task<T> ToEntityAsync(IClientSessionHandle session = null, CancellationToken cancellation = default, string tenantPrefix = null)
+        //{
+        //    return new Find<T>(session, null, tenantPrefix).OneAsync(ID, cancellation);
+        //}
 
-        /// <summary>
-        /// Fetches the actual entity this reference represents from the database with a projection.
-        /// </summary>
-        /// <param name="projection">x => new Test { PropName = x.Prop }</param>
-        /// <param name="session">An optional session if using within a transaction</param>
-        /// <param name = "cancellation" > An optional cancellation token</param>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        /// <returns>A Task containing the actual projected entity</returns>
-        public async Task<T> ToEntityAsync(Expression<Func<T, T>> projection, IClientSessionHandle session = null, CancellationToken cancellation = default, string tenantPrefix = null)
-        {
-            return (await new Find<T>(session, null, tenantPrefix)
-                        .Match(ID)
-                        .Project(projection)
-                        .ExecuteAsync(cancellation).ConfigureAwait(false))
-                   .SingleOrDefault();
-        }
+        ///// <summary>
+        ///// Fetches the actual entity this reference represents from the database with a projection.
+        ///// </summary>
+        ///// <param name="projection">x => new Test { PropName = x.Prop }</param>
+        ///// <param name="session">An optional session if using within a transaction</param>
+        ///// <param name = "cancellation" > An optional cancellation token</param>
+        ///// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
+        ///// <returns>A Task containing the actual projected entity</returns>
+        //public async Task<T> ToEntityAsync(Expression<Func<T, T>> projection, IClientSessionHandle session = null, CancellationToken cancellation = default, string tenantPrefix = null)
+        //{
+        //    return (await new Find<T>(session, null, tenantPrefix)
+        //                .Match(ID)
+        //                .Project(projection)
+        //                .ExecuteAsync(cancellation).ConfigureAwait(false))
+        //           .SingleOrDefault();
+        //}
 
-        /// <summary>
-        /// Fetches the actual entity this reference represents from the database with a projection.
-        /// </summary>
-        /// <param name="projection">p=> p.Include("Prop1").Exclude("Prop2")</param>
-        /// <param name="session">An optional session if using within a transaction</param>
-        /// <param name = "cancellation" > An optional cancellation token</param>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        /// <returns>A Task containing the actual projected entity</returns>
-        public async Task<T> ToEntityAsync(Func<ProjectionDefinitionBuilder<T>, ProjectionDefinition<T, T>> projection, IClientSessionHandle session = null, CancellationToken cancellation = default, string tenantPrefix = null)
-        {
-            return (await new Find<T>(session, null, tenantPrefix)
-                        .Match(ID)
-                        .Project(projection)
-                        .ExecuteAsync(cancellation).ConfigureAwait(false))
-                   .SingleOrDefault();
-        }
+        ///// <summary>
+        ///// Fetches the actual entity this reference represents from the database with a projection.
+        ///// </summary>
+        ///// <param name="projection">p=> p.Include("Prop1").Exclude("Prop2")</param>
+        ///// <param name="session">An optional session if using within a transaction</param>
+        ///// <param name = "cancellation" > An optional cancellation token</param>
+        ///// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
+        ///// <returns>A Task containing the actual projected entity</returns>
+        //public async Task<T> ToEntityAsync(Func<ProjectionDefinitionBuilder<T>, ProjectionDefinition<T, T>> projection, IClientSessionHandle session = null, CancellationToken cancellation = default, string tenantPrefix = null)
+        //{
+        //    return (await new Find<T>(session, null, tenantPrefix)
+        //                .Match(ID)
+        //                .Project(projection)
+        //                .ExecuteAsync(cancellation).ConfigureAwait(false))
+        //           .SingleOrDefault();
+        //}
     }
 }

From 2e15d5904af4b592f80b28ea74d19e01597460cd Mon Sep 17 00:00:00 2001
From: Ahmed Fwela <ahmednfwela@bdaya-dev.com>
Date: Sat, 6 Nov 2021 02:10:54 +0200
Subject: [PATCH 10/26] WIP

---
 MongoDB.Entities/Builders/Update.cs           | 15 +-------
 MongoDB.Entities/Core/Logic.cs                | 10 +++---
 MongoDB.Entities/Core/MongoContextOptions.cs  |  4 +--
 MongoDB.Entities/DB/DB.Count.cs               | 35 ++++++------------
 MongoDB.Entities/DB/DB.Delete.cs              |  2 +-
 MongoDB.Entities/DB/DB.Queryable.cs           |  8 ++---
 .../DBContext/DBContext.Collection.cs         |  1 -
 MongoDB.Entities/DBContext/DBContext.Count.cs | 36 +++++++------------
 .../DBContext/DBContext.Delete.cs             |  3 +-
 .../DBContext/DBContext.Queryable.cs          | 11 +++---
 MongoDB.Entities/DBContext/DBContext.cs       | 13 ++++---
 11 files changed, 47 insertions(+), 91 deletions(-)

diff --git a/MongoDB.Entities/Builders/Update.cs b/MongoDB.Entities/Builders/Update.cs
index 7fadaf296..6498f1910 100644
--- a/MongoDB.Entities/Builders/Update.cs
+++ b/MongoDB.Entities/Builders/Update.cs
@@ -11,9 +11,6 @@ namespace MongoDB.Entities
 {
     public class UpdateBase<T, TSelf> : FilterQueryBase<T, TSelf> where T : IEntity where TSelf : UpdateBase<T, TSelf>
     {
-        //note: this base class exists for facilating the OnBeforeUpdate custom hook of DBContext class
-        //      there's no other purpose for this.
-
         protected readonly List<UpdateDefinition<T>> defs;
         protected readonly Action<TSelf>? onUpdateAction;
 
@@ -65,17 +62,7 @@ public void AddModification(Template template)
         {
             AddModification(template.RenderToString());
         }
-
-        //protected void SetTenantDbOnFileEntities(string tenantPrefix)
-        //{
-        //    if (Cache<T>.Instance.IsFileEntity)
-        //    {
-        //        defs.Add(Builders<T>.Update.Set(
-        //            nameof(FileEntity.TenantPrefix),
-        //            Cache<T>.Instance.Collection(tenantPrefix).Database.DatabaseNamespace.DatabaseName));
-        //    }
-        //}
-
+   
 
         /// <summary>
         /// Specify the property and it's value to modify (use multiple times if needed)
diff --git a/MongoDB.Entities/Core/Logic.cs b/MongoDB.Entities/Core/Logic.cs
index eb5747e56..16c6ba9e5 100644
--- a/MongoDB.Entities/Core/Logic.cs
+++ b/MongoDB.Entities/Core/Logic.cs
@@ -9,17 +9,17 @@ namespace MongoDB.Entities
 {
     internal static class Logic
     {
-        internal static IEnumerable<UpdateDefinition<T>> BuildUpdateDefs<T>(T entity) where T : IEntity
+        internal static IEnumerable<UpdateDefinition<T>> BuildUpdateDefs<T>(T entity, DBContext? context = null) where T : IEntity
         {
             if (entity == null)
                 throw new ArgumentException("The supplied entity cannot be null!");
 
-            var props = Cache<T>.UpdatableProps(entity);
+            var props = (context?.Cache<T>() ?? Cache<T>.Instance).UpdatableProps(entity);
 
             return props.Select(p => Builders<T>.Update.Set(p.Name, p.GetValue(entity)));
         }
 
-        internal static IEnumerable<UpdateDefinition<T>> BuildUpdateDefs<T>(T entity, Expression<Func<T, object>> members, bool excludeMode = false) where T : IEntity
+        internal static IEnumerable<UpdateDefinition<T>> BuildUpdateDefs<T>(T entity, Expression<Func<T, object>> members, bool excludeMode = false, DBContext? context = null) where T : IEntity
         {
             var propNames = (members?.Body as NewExpression)?.Arguments
                 .Select(a => a.ToString().Split('.')[1]);
@@ -27,7 +27,7 @@ internal static IEnumerable<UpdateDefinition<T>> BuildUpdateDefs<T>(T entity, Ex
             if (!propNames.Any())
                 throw new ArgumentException("Unable to get any properties from the members expression!");
 
-            var props = Cache<T>.UpdatableProps(entity);
+            var props = (context?.Cache<T>() ?? Cache<T>.Instance).UpdatableProps(entity);
 
             if (excludeMode)
                 props = props.Where(p => !propNames.Contains(p.Name));
@@ -37,7 +37,7 @@ internal static IEnumerable<UpdateDefinition<T>> BuildUpdateDefs<T>(T entity, Ex
             return props.Select(p => Builders<T>.Update.Set(p.Name, p.GetValue(entity)));
         }
 
-        internal static FilterDefinition<T> MergeWithGlobalFilter<T>(bool ignoreGlobalFilters, Dictionary<Type, (object filterDef, bool prepend)> globalFilters, FilterDefinition<T> filter) where T : IEntity
+        internal static FilterDefinition<T> MergeWithGlobalFilter<T>(bool ignoreGlobalFilters, Dictionary<Type, (object filterDef, bool prepend)>? globalFilters, FilterDefinition<T> filter) where T : IEntity
         {
             //WARNING: this has to do the same thing as DBContext.Pipeline.MergeWithGlobalFilter method
             //         if the following logic changes, update the other method also
diff --git a/MongoDB.Entities/Core/MongoContextOptions.cs b/MongoDB.Entities/Core/MongoContextOptions.cs
index 503267109..8403c13eb 100644
--- a/MongoDB.Entities/Core/MongoContextOptions.cs
+++ b/MongoDB.Entities/Core/MongoContextOptions.cs
@@ -9,16 +9,14 @@ namespace MongoDB.Entities
 {
     public class MongoContextOptions
     {
-        public MongoContextOptions(ModifiedBy? modifiedBy = null, string? tenantId = null)
+        public MongoContextOptions(ModifiedBy? modifiedBy = null)
         {
             ModifiedBy = modifiedBy;
-            TenantId = tenantId;
         }
 
         /// <summary>
         /// The value of this property will be automatically set on entities when saving/updating if the entity has a ModifiedBy property
         /// </summary>
         public ModifiedBy? ModifiedBy { get; set; }
-        public string? TenantId { get; set; }
     }
 }
diff --git a/MongoDB.Entities/DB/DB.Count.cs b/MongoDB.Entities/DB/DB.Count.cs
index 367fed665..dd923c63d 100644
--- a/MongoDB.Entities/DB/DB.Count.cs
+++ b/MongoDB.Entities/DB/DB.Count.cs
@@ -15,9 +15,9 @@ public static partial class DB
         /// <typeparam name="T">The entity type to get the count for</typeparam>
         /// <param name="cancellation">An optional cancellation token</param>
         /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static Task<long> CountEstimatedAsync<T>(CancellationToken cancellation = default, string tenantPrefix = null) where T : IEntity
+        public static Task<long> CountEstimatedAsync<T>(CancellationToken cancellation = default) where T : IEntity
         {
-            return Collection<T>(tenantPrefix).EstimatedDocumentCountAsync(null, cancellation);
+            return Context.CountEstimatedAsync<T>(cancellation);
         }
 
         /// <summary>
@@ -25,16 +25,11 @@ public static Task<long> CountEstimatedAsync<T>(CancellationToken cancellation =
         /// </summary>
         /// <typeparam name="T">The entity type to get the count for</typeparam>
         /// <param name="expression">A lambda expression for getting the count for a subset of the data</param>
-        /// <param name="session">An optional session if using within a transaction</param>
         /// <param name="cancellation">An optional cancellation token</param>
         /// <param name="options">An optional CountOptions object</param>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static Task<long> CountAsync<T>(Expression<Func<T, bool>> expression, IClientSessionHandle session = null, CancellationToken cancellation = default, CountOptions options = null, string tenantPrefix = null) where T : IEntity
+        public static Task<long> CountAsync<T>(Expression<Func<T, bool>> expression, CancellationToken cancellation = default, CountOptions? options = null) where T : IEntity
         {
-            return
-                 session == null
-                 ? Collection<T>(tenantPrefix).CountDocumentsAsync(expression, options, cancellation)
-                 : Collection<T>(tenantPrefix).CountDocumentsAsync(session, expression, options, cancellation);
+            return Context.CountAsync(expression, cancellation, options);
         }
 
         /// <summary>
@@ -42,16 +37,11 @@ public static Task<long> CountAsync<T>(Expression<Func<T, bool>> expression, ICl
         /// </summary>
         /// <typeparam name="T">The entity type to get the count for</typeparam>
         /// <param name="filter">A filter definition</param>
-        /// <param name="session">An optional session if using within a transaction</param>
         /// <param name="cancellation">An optional cancellation token</param>
         /// <param name="options">An optional CountOptions object</param>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static Task<long> CountAsync<T>(FilterDefinition<T> filter, IClientSessionHandle session = null, CancellationToken cancellation = default, CountOptions options = null, string tenantPrefix = null) where T : IEntity
+        public static Task<long> CountAsync<T>(FilterDefinition<T> filter, CancellationToken cancellation = default, CountOptions? options = null) where T : IEntity
         {
-            return
-                 session == null
-                 ? Collection<T>(tenantPrefix).CountDocumentsAsync(filter, options, cancellation)
-                 : Collection<T>(tenantPrefix).CountDocumentsAsync(session, filter, options, cancellation);
+            return Context.CountAsync(filter, cancellation, options);
         }
 
         /// <summary>
@@ -63,24 +53,19 @@ public static Task<long> CountAsync<T>(FilterDefinition<T> filter, IClientSessio
         /// <param name="cancellation">An optional cancellation token</param>
         /// <param name="options">An optional CountOptions object</param>
         /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static Task<long> CountAsync<T>(Func<FilterDefinitionBuilder<T>, FilterDefinition<T>> filter, IClientSessionHandle session = null, CancellationToken cancellation = default, CountOptions options = null, string tenantPrefix = null) where T : IEntity
+        public static Task<long> CountAsync<T>(Func<FilterDefinitionBuilder<T>, FilterDefinition<T>> filter, CancellationToken cancellation = default, CountOptions? options = null) where T : IEntity
         {
-            return
-                 session == null
-                 ? Collection<T>(tenantPrefix).CountDocumentsAsync(filter(Builders<T>.Filter), options, cancellation)
-                 : Collection<T>(tenantPrefix).CountDocumentsAsync(session, filter(Builders<T>.Filter), options, cancellation);
+            return Context.CountAsync(filter, cancellation, options);
         }
 
         /// <summary>
         /// Gets an accurate count of how many total entities are in the collection for a given entity type
         /// </summary>
         /// <typeparam name="T">The entity type to get the count for</typeparam>
-        /// <param name="session">An optional session if using within a transaction</param>
         /// <param name="cancellation">An optional cancellation token</param>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static Task<long> CountAsync<T>(IClientSessionHandle session = null, CancellationToken cancellation = default, string tenantPrefix = null) where T : IEntity
+        public static Task<long> CountAsync<T>(CancellationToken cancellation = default) where T : IEntity
         {
-            return CountAsync<T>(_ => true, session, cancellation, tenantPrefix: tenantPrefix);
+            return Context.CountAsync<T>(cancellation);
         }
     }
 }
diff --git a/MongoDB.Entities/DB/DB.Delete.cs b/MongoDB.Entities/DB/DB.Delete.cs
index 1f1c51373..2171fc0e4 100644
--- a/MongoDB.Entities/DB/DB.Delete.cs
+++ b/MongoDB.Entities/DB/DB.Delete.cs
@@ -152,7 +152,7 @@ public static Task<DeleteResult> DeleteAsync<T>(Func<FilterDefinitionBuilder<T>,
         /// <param name="cancellation">An optional cancellation token</param>
         /// <param name="collation">An optional collation object</param>
         /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static async Task<DeleteResult> DeleteAsync<T>(FilterDefinition<T> filter, IClientSessionHandle session = null, CancellationToken cancellation = default, Collation collation = null, string tenantPrefix = null) where T : IEntity
+        public static async Task<DeleteResult> DeleteAsync<T>(FilterDefinition<T> filter, IClientSessionHandle? session = null, CancellationToken cancellation = default, Collation? collation = null) where T : IEntity
         {
             ThrowIfCancellationNotSupported(session, cancellation);
 
diff --git a/MongoDB.Entities/DB/DB.Queryable.cs b/MongoDB.Entities/DB/DB.Queryable.cs
index 13e2cfca5..f75126adf 100644
--- a/MongoDB.Entities/DB/DB.Queryable.cs
+++ b/MongoDB.Entities/DB/DB.Queryable.cs
@@ -9,14 +9,10 @@ public static partial class DB
         /// Exposes the MongoDB collection for the given IEntity as an IQueryable in order to facilitate LINQ queries.
         /// </summary>
         /// <param name="options">The aggregate options</param>
-        /// <param name="session">An optional session if used within a transaction</param>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
         /// <typeparam name="T">Any class that implements IEntity</typeparam>
-        public static IMongoQueryable<T> Queryable<T>(AggregateOptions options = null, IClientSessionHandle session = null, string tenantPrefix = null) where T : IEntity
+        public static IMongoQueryable<T> Queryable<T>(AggregateOptions? options = null) where T : IEntity
         {
-            return session == null
-                   ? Collection<T>(tenantPrefix).AsQueryable(options)
-                   : Collection<T>(tenantPrefix).AsQueryable(session, options);
+            return Context.Queryable<T>(options);
         }
     }
 }
diff --git a/MongoDB.Entities/DBContext/DBContext.Collection.cs b/MongoDB.Entities/DBContext/DBContext.Collection.cs
index 93a106202..e0d632daf 100644
--- a/MongoDB.Entities/DBContext/DBContext.Collection.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Collection.cs
@@ -21,7 +21,6 @@ public Task CreateCollectionAsync<T>(Action<CreateCollectionOptions<T>> options,
             return Session == null
                   ? Database.CreateCollectionAsync(Cache<T>().CollectionName, opts, cancellation)
                   : Database.CreateCollectionAsync(Session, Cache<T>().CollectionName, opts, cancellation);
-
         }
 
         /// <summary>
diff --git a/MongoDB.Entities/DBContext/DBContext.Count.cs b/MongoDB.Entities/DBContext/DBContext.Count.cs
index ba593a507..e1be5fcbf 100644
--- a/MongoDB.Entities/DBContext/DBContext.Count.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Count.cs
@@ -16,7 +16,7 @@ public partial class DBContext
         /// <param name="cancellation">An optional cancellation token</param>
         public Task<long> CountEstimatedAsync<T>(CancellationToken cancellation = default) where T : IEntity
         {
-            return DB.CountEstimatedAsync<T>(cancellation, tenantPrefix);
+            return CollectionFor<T>().EstimatedDocumentCountAsync(cancellationToken: cancellation);
         }
 
         /// <summary>
@@ -27,14 +27,9 @@ public Task<long> CountEstimatedAsync<T>(CancellationToken cancellation = defaul
         /// <param name="cancellation">An optional cancellation token</param>
         /// <param name="options">An optional CountOptions object</param>
         /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
-        public Task<long> CountAsync<T>(Expression<Func<T, bool>> expression, CancellationToken cancellation = default, CountOptions options = null, bool ignoreGlobalFilters = false) where T : IEntity
+        public Task<long> CountAsync<T>(Expression<Func<T, bool>> expression, CancellationToken cancellation = default, CountOptions? options = null, bool ignoreGlobalFilters = false) where T : IEntity
         {
-            return DB.CountAsync(
-                Logic.MergeWithGlobalFilter<T>(ignoreGlobalFilters, _globalFilters, expression),
-                Session,
-                cancellation,
-                options,
-                tenantPrefix);
+            return CountAsync((FilterDefinition<T>)expression, cancellation, options, ignoreGlobalFilters);
         }
 
         /// <summary>
@@ -44,7 +39,8 @@ public Task<long> CountAsync<T>(Expression<Func<T, bool>> expression, Cancellati
         /// <param name="cancellation">An optional cancellation token</param>
         public Task<long> CountAsync<T>(CancellationToken cancellation = default) where T : IEntity
         {
-            return DB.CountAsync<T>(Session, cancellation, tenantPrefix);
+            return CountAsync<T>(_ => true, cancellation);
+
         }
 
         /// <summary>
@@ -55,14 +51,13 @@ public Task<long> CountAsync<T>(CancellationToken cancellation = default) where
         /// <param name="cancellation">An optional cancellation token</param>
         /// <param name="options">An optional CountOptions object</param>
         /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
-        public Task<long> CountAsync<T>(FilterDefinition<T> filter, CancellationToken cancellation = default, CountOptions options = null, bool ignoreGlobalFilters = false) where T : IEntity
+        public Task<long> CountAsync<T>(FilterDefinition<T> filter, CancellationToken cancellation = default, CountOptions? options = null, bool ignoreGlobalFilters = false) where T : IEntity
         {
-            return DB.CountAsync(
-                Logic.MergeWithGlobalFilter(ignoreGlobalFilters, _globalFilters, filter),
-                Session,
-                cancellation,
-                options,
-                tenantPrefix);
+            filter = Logic.MergeWithGlobalFilter(ignoreGlobalFilters, _globalFilters, filter);
+            return
+                 Session == null
+                 ? CollectionFor<T>().CountDocumentsAsync(filter, options, cancellation)
+                 : CollectionFor<T>().CountDocumentsAsync(Session, filter, options, cancellation);
         }
 
         /// <summary>
@@ -73,14 +68,9 @@ public Task<long> CountAsync<T>(FilterDefinition<T> filter, CancellationToken ca
         /// <param name="cancellation">An optional cancellation token</param>
         /// <param name="options">An optional CountOptions object</param>
         /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
-        public Task<long> CountAsync<T>(Func<FilterDefinitionBuilder<T>, FilterDefinition<T>> filter, CancellationToken cancellation = default, CountOptions options = null, bool ignoreGlobalFilters = false) where T : IEntity
+        public Task<long> CountAsync<T>(Func<FilterDefinitionBuilder<T>, FilterDefinition<T>> filter, CancellationToken cancellation = default, CountOptions? options = null, bool ignoreGlobalFilters = false) where T : IEntity
         {
-            return DB.CountAsync(
-                Logic.MergeWithGlobalFilter(ignoreGlobalFilters, _globalFilters, filter(Builders<T>.Filter)),
-                Session,
-                cancellation,
-                options,
-                tenantPrefix);
+            return CountAsync(filter(Builders<T>.Filter), cancellation, options, ignoreGlobalFilters);
         }
     }
 }
diff --git a/MongoDB.Entities/DBContext/DBContext.Delete.cs b/MongoDB.Entities/DBContext/DBContext.Delete.cs
index e5567f1c9..cb46b46dd 100644
--- a/MongoDB.Entities/DBContext/DBContext.Delete.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Delete.cs
@@ -22,8 +22,7 @@ public Task<DeleteResult> DeleteAsync<T>(string ID, CancellationToken cancellati
             return DB.DeleteAsync(
                 Logic.MergeWithGlobalFilter(ignoreGlobalFilters, _globalFilters, Builders<T>.Filter.Eq(e => e.ID, ID)),
                 Session,
-                cancellation,
-                tenantPrefix: tenantPrefix);
+                cancellation);
         }
 
         /// <summary>
diff --git a/MongoDB.Entities/DBContext/DBContext.Queryable.cs b/MongoDB.Entities/DBContext/DBContext.Queryable.cs
index 6dda35e32..608c0627a 100644
--- a/MongoDB.Entities/DBContext/DBContext.Queryable.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Queryable.cs
@@ -11,17 +11,20 @@ public partial class DBContext
         /// <param name="options">The aggregate options</param>
         /// <typeparam name="T">The type of entity</typeparam>
         /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
-        public IMongoQueryable<T> Queryable<T>(AggregateOptions options = null, bool ignoreGlobalFilters = false) where T : IEntity
+        public IMongoQueryable<T> Queryable<T>(AggregateOptions? options = null, bool ignoreGlobalFilters = false) where T : IEntity
         {
             var globalFilter = Logic.MergeWithGlobalFilter(ignoreGlobalFilters, _globalFilters, Builders<T>.Filter.Empty);
 
+            var q = Session == null
+               ? CollectionFor<T>().AsQueryable(options)
+               : CollectionFor<T>().AsQueryable(Session, options);
+
             if (globalFilter != Builders<T>.Filter.Empty)
             {
-                return DB.Queryable<T>(options, Session, tenantPrefix)
-                         .Where(_ => globalFilter.Inject());
+                q = q.Where(_ => globalFilter.Inject());
             }
 
-            return DB.Queryable<T>(options, Session, tenantPrefix);
+            return q;
         }
     }
 }
diff --git a/MongoDB.Entities/DBContext/DBContext.cs b/MongoDB.Entities/DBContext/DBContext.cs
index 2e9646370..39057a4c0 100644
--- a/MongoDB.Entities/DBContext/DBContext.cs
+++ b/MongoDB.Entities/DBContext/DBContext.cs
@@ -47,7 +47,8 @@ public ModifiedBy? ModifiedBy
 
         public MongoDatabaseSettings Settings => Database.Settings;
 
-        private Dictionary<Type, (object filterDef, bool prepend)> _globalFilters = new();
+        private Dictionary<Type, (object filterDef, bool prepend)>? _globalFilters;
+        private Dictionary<Type, (object filterDef, bool prepend)> GlobalFilters => _globalFilters ??= new();
 
         /// <summary>
         /// Copy constructor
@@ -69,7 +70,7 @@ public DBContext(MongoContext mongoContext, string database, MongoDatabaseSettin
         {
             MongoContext = mongoContext;
             Options = options ?? new();
-            Database = mongoContext.GetDatabase((mongoContext.Options.TenantId ?? "") + database, settings);
+            Database = mongoContext.GetDatabase(database, settings);
         }
 
         /// <summary>
@@ -96,7 +97,7 @@ public DBContext(string database, string host = "127.0.0.1", int port = 27017, M
                     ModifiedBy = modifiedBy
                 });
             Options = new();
-            Database = MongoContext.GetDatabase((MongoContext.Options.TenantId ?? "") + database);
+            Database = MongoContext.GetDatabase(database);
         }
 
         /// <summary>
@@ -118,7 +119,7 @@ public DBContext(string database, MongoClientSettings settings, ModifiedBy? modi
                    ModifiedBy = modifiedBy
                });
             Options = new();
-            Database = MongoContext.GetDatabase((MongoContext.Options.TenantId ?? "") + database);
+            Database = MongoContext.GetDatabase(database);
         }
 
 
@@ -276,9 +277,7 @@ private void ThrowIfModifiedByIsEmpty<T>() where T : IEntity
 
         private void AddFilter(Type type, (object filterDef, bool prepend) filter)
         {
-            if (_globalFilters is null) _globalFilters = new Dictionary<Type, (object filterDef, bool prepend)>();
-
-            _globalFilters[type] = filter;
+            GlobalFilters[type] = filter;
         }
 
 

From 389d86f8ab55d24d2a45cfb0af9dd21535401aee Mon Sep 17 00:00:00 2001
From: Ahmed Fwela <ahmednfwela@bdaya-dev.com>
Date: Sat, 6 Nov 2021 02:11:29 +0200
Subject: [PATCH 11/26] Rename

---
 MongoDB.Entities/DBContext/DBContext.cs       | 32 +++++++++----------
 .../MongoContext/MongoContext.IMongoClient.cs |  2 +-
 MongoDB.Entities/MongoContext/MongoContext.cs |  4 +--
 3 files changed, 19 insertions(+), 19 deletions(-)

diff --git a/MongoDB.Entities/DBContext/DBContext.cs b/MongoDB.Entities/DBContext/DBContext.cs
index 39057a4c0..3c4409cb7 100644
--- a/MongoDB.Entities/DBContext/DBContext.cs
+++ b/MongoDB.Entities/DBContext/DBContext.cs
@@ -21,27 +21,27 @@ public partial class DBContext : IMongoDatabase
         public IClientSessionHandle? Session { get; protected set; }
 
 
-        public MongoContext MongoContext { get; set; }
+        public MongoServerContext MongoServerContext { get; set; }
         public IMongoDatabase Database { get; set; }
         public DBContextOptions Options { get; set; }
 
         /// <summary>
-        /// wrapper around <see cref="MongoContext.ModifiedBy"/> so that we don't break the public api
+        /// wrapper around <see cref="MongoServerContext.ModifiedBy"/> so that we don't break the public api
         /// </summary>
         public ModifiedBy? ModifiedBy
         {
             get
             {
-                return MongoContext.ModifiedBy;
+                return MongoServerContext.ModifiedBy;
             }
             [Obsolete("Use MongoContext.Options.ModifiedBy = value instead")]
             set
             {
-                MongoContext.Options.ModifiedBy = value;
+                MongoServerContext.Options.ModifiedBy = value;
             }
         }
 
-        public IMongoClient Client => MongoContext;
+        public IMongoClient Client => MongoServerContext;
 
         public DatabaseNamespace DatabaseNamespace => Database.DatabaseNamespace;
 
@@ -56,19 +56,19 @@ public ModifiedBy? ModifiedBy
         /// <param name="other"></param>
         public DBContext(DBContext other)
         {
-            MongoContext = other.MongoContext;
+            MongoServerContext = other.MongoServerContext;
             Database = other.Database;
             Options = other.Options;
         }
-        public DBContext(MongoContext mongoContext, IMongoDatabase database, DBContextOptions? options = null)
+        public DBContext(MongoServerContext mongoContext, IMongoDatabase database, DBContextOptions? options = null)
         {
-            MongoContext = mongoContext;
+            MongoServerContext = mongoContext;
             Database = database;
             Options = options ?? new();
         }
-        public DBContext(MongoContext mongoContext, string database, MongoDatabaseSettings? settings = null, DBContextOptions? options = null)
+        public DBContext(MongoServerContext mongoContext, string database, MongoDatabaseSettings? settings = null, DBContextOptions? options = null)
         {
-            MongoContext = mongoContext;
+            MongoServerContext = mongoContext;
             Options = options ?? new();
             Database = mongoContext.GetDatabase(database, settings);
         }
@@ -86,7 +86,7 @@ public DBContext(MongoContext mongoContext, string database, MongoDatabaseSettin
         /// Only one ModifiedBy property is allowed on a single entity type.</param>
         public DBContext(string database, string host = "127.0.0.1", int port = 27017, ModifiedBy? modifiedBy = null)
         {
-            MongoContext = new MongoContext(
+            MongoServerContext = new MongoServerContext(
                 client: new MongoClient(
                     new MongoClientSettings
                     {
@@ -97,7 +97,7 @@ public DBContext(string database, string host = "127.0.0.1", int port = 27017, M
                     ModifiedBy = modifiedBy
                 });
             Options = new();
-            Database = MongoContext.GetDatabase(database);
+            Database = MongoServerContext.GetDatabase(database);
         }
 
         /// <summary>
@@ -112,14 +112,14 @@ public DBContext(string database, string host = "127.0.0.1", int port = 27017, M
         /// Only one ModifiedBy property is allowed on a single entity type.</param>
         public DBContext(string database, MongoClientSettings settings, ModifiedBy? modifiedBy = null)
         {
-            MongoContext = new MongoContext(
+            MongoServerContext = new MongoServerContext(
                client: new MongoClient(settings),
                options: new()
                {
                    ModifiedBy = modifiedBy
                });
             Options = new();
-            Database = MongoContext.GetDatabase(database);
+            Database = MongoServerContext.GetDatabase(database);
         }
 
 
@@ -234,7 +234,7 @@ protected void SetGlobalFilterForBaseClass<TBase>(Func<FilterDefinitionBuilder<T
         /// <param name="prepend">Set to true if you want to prepend this global filter to your operation filters instead of being appended</param>
         protected void SetGlobalFilterForBaseClass<TBase>(FilterDefinition<TBase> filter, bool prepend = false) where TBase : IEntity
         {
-            foreach (var entType in MongoContext.AllEntitiyTypes.Where(t => t.IsSubclassOf(typeof(TBase))))
+            foreach (var entType in MongoServerContext.AllEntitiyTypes.Where(t => t.IsSubclassOf(typeof(TBase))))
             {
                 var bsonDoc = filter.Render(
                     BsonSerializer.SerializerRegistry.GetSerializer<TBase>(),
@@ -257,7 +257,7 @@ protected void SetGlobalFilterForInterface<TInterface>(string jsonString, bool p
             if (!targetType.IsInterface) throw new ArgumentException("Only interfaces are allowed!", "TInterface");
 
 
-            foreach (var entType in MongoContext.AllEntitiyTypes.Where(t => targetType.IsAssignableFrom(t)))
+            foreach (var entType in MongoServerContext.AllEntitiyTypes.Where(t => targetType.IsAssignableFrom(t)))
             {
                 AddFilter(entType, (jsonString, prepend));
             }
diff --git a/MongoDB.Entities/MongoContext/MongoContext.IMongoClient.cs b/MongoDB.Entities/MongoContext/MongoContext.IMongoClient.cs
index fd475a6ec..a3cbe7bfd 100644
--- a/MongoDB.Entities/MongoContext/MongoContext.IMongoClient.cs
+++ b/MongoDB.Entities/MongoContext/MongoContext.IMongoClient.cs
@@ -10,7 +10,7 @@
 namespace MongoDB.Entities
 {
     //Make these interface implmentation explicit, so we can fine-tune the api return result
-    public partial class MongoContext
+    public partial class MongoServerContext
     {
         public ICluster Cluster => Client.Cluster;
 
diff --git a/MongoDB.Entities/MongoContext/MongoContext.cs b/MongoDB.Entities/MongoContext/MongoContext.cs
index 3e0253446..6833ff3e6 100644
--- a/MongoDB.Entities/MongoContext/MongoContext.cs
+++ b/MongoDB.Entities/MongoContext/MongoContext.cs
@@ -10,14 +10,14 @@ namespace MongoDB.Entities
     /// <summary>
     /// MongoContext is a wrapper around an <see cref="IMongoClient"/>
     /// </summary>
-    public partial class MongoContext : IMongoClient
+    public partial class MongoServerContext : IMongoClient
     {
         /// <summary>
         /// Creates a new context
         /// </summary>        
         /// <param name="client">The backing client, usually a <see cref="MongoClient"/></param>
         /// <param name="options">The options to configure the context</param>
-        public MongoContext(IMongoClient client, MongoContextOptions? options = null)
+        public MongoServerContext(IMongoClient client, MongoContextOptions? options = null)
         {
             Client = client;
             Options = options ?? new();

From 2d93a7d5cda13536260c37079ab026497189e1fe Mon Sep 17 00:00:00 2001
From: Ahmed Fwela <ahmednfwela@bdaya-dev.com>
Date: Tue, 9 Nov 2021 18:39:11 +0200
Subject: [PATCH 12/26] fixed Delete

---
 MongoDB.Entities/DB/DB.Delete.cs              | 133 ++----------------
 .../DBContext/DBContext.Delete.cs             | 123 ++++++++++++----
 2 files changed, 103 insertions(+), 153 deletions(-)

diff --git a/MongoDB.Entities/DB/DB.Delete.cs b/MongoDB.Entities/DB/DB.Delete.cs
index 2171fc0e4..98b085483 100644
--- a/MongoDB.Entities/DB/DB.Delete.cs
+++ b/MongoDB.Entities/DB/DB.Delete.cs
@@ -10,57 +10,6 @@ namespace MongoDB.Entities
 {
     public static partial class DB
     {
-        private static readonly int deleteBatchSize = 100000;
-
-        private static async Task<DeleteResult> DeleteCascadingAsync<T>(string tenantPrefix,
-            IEnumerable<string> IDs,
-            IClientSessionHandle session = null,
-            CancellationToken cancellation = default) where T : IEntity
-        {
-            // note: cancellation should not be enabled outside of transactions because multiple collections are involved 
-            //       and premature cancellation could cause data inconsistencies.
-            //       i.e. don't pass the cancellation token to delete methods below that don't take a session.
-            //       also make consumers call ThrowIfCancellationNotSupported() before calling this method.
-
-            var db = Database<T>(tenantPrefix);
-            var options = new ListCollectionNamesOptions
-            {
-                Filter = "{$and:[{name:/~/},{name:/" + CollectionName<T>() + "/}]}"
-            };
-
-            var tasks = new List<Task>();
-
-            // note: db.listCollections() mongo command does not support transactions.
-            //       so don't add session support here.
-            var collNamesCursor = await db.ListCollectionNamesAsync(options, cancellation).ConfigureAwait(false);
-
-            foreach (var cName in await collNamesCursor.ToListAsync(cancellation).ConfigureAwait(false))
-            {
-                tasks.Add(
-                    session == null
-                    ? db.GetCollection<JoinRecord>(cName).DeleteManyAsync(r => IDs.Contains(r.ChildID) || IDs.Contains(r.ParentID))
-                    : db.GetCollection<JoinRecord>(cName).DeleteManyAsync(session, r => IDs.Contains(r.ChildID) || IDs.Contains(r.ParentID), null, cancellation));
-            }
-
-            var delResTask =
-                    session == null
-                    ? Collection<T>(tenantPrefix).DeleteManyAsync(x => IDs.Contains(x.ID))
-                    : Collection<T>(tenantPrefix).DeleteManyAsync(session, x => IDs.Contains(x.ID), null, cancellation);
-
-            tasks.Add(delResTask);
-
-            if (typeof(T).BaseType == typeof(FileEntity))
-            {
-                tasks.Add(
-                    session == null
-                    ? db.GetCollection<FileChunk>(CollectionName<FileChunk>()).DeleteManyAsync(x => IDs.Contains(x.FileID))
-                    : db.GetCollection<FileChunk>(CollectionName<FileChunk>()).DeleteManyAsync(session, x => IDs.Contains(x.FileID), null, cancellation));
-            }
-
-            await Task.WhenAll(tasks).ConfigureAwait(false);
-
-            return await delResTask.ConfigureAwait(false);
-        }
 
         /// <summary>
         /// Deletes a single entity from MongoDB.
@@ -68,13 +17,10 @@ private static async Task<DeleteResult> DeleteCascadingAsync<T>(string tenantPre
         /// </summary>
         /// <typeparam name="T">Any class that implements IEntity</typeparam>
         /// <param name="ID">The Id of the entity to delete</param>
-        /// <param name = "session" >An optional session if using within a transaction</param>
         /// <param name="cancellation">An optional cancellation token</param>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static Task<DeleteResult> DeleteAsync<T>(string ID, IClientSessionHandle session = null, CancellationToken cancellation = default, string tenantPrefix = null) where T : IEntity
+        public static Task<DeleteResult> DeleteAsync<T>(string ID, CancellationToken cancellation = default) where T : IEntity
         {
-            ThrowIfCancellationNotSupported(session, cancellation);
-            return DeleteCascadingAsync<T>(tenantPrefix, new[] { ID }, session, cancellation);
+            return Context.DeleteAsync<T>(ID, cancellation);
         }
 
         /// <summary>
@@ -84,29 +30,10 @@ public static Task<DeleteResult> DeleteAsync<T>(string ID, IClientSessionHandle
         /// </summary>
         /// <typeparam name="T">Any class that implements IEntity</typeparam>
         /// <param name="IDs">An IEnumerable of entity IDs</param>
-        /// <param name = "session" > An optional session if using within a transaction</param>
         /// <param name="cancellation">An optional cancellation token</param>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static async Task<DeleteResult> DeleteAsync<T>(IEnumerable<string> IDs, IClientSessionHandle session = null, CancellationToken cancellation = default, string tenantPrefix = null) where T : IEntity
+        public static Task<DeleteResult> DeleteAsync<T>(IEnumerable<string> IDs, CancellationToken cancellation = default) where T : IEntity
         {
-            ThrowIfCancellationNotSupported(session, cancellation);
-
-            if (IDs.Count() <= deleteBatchSize)
-                return await DeleteCascadingAsync<T>(tenantPrefix, IDs, session, cancellation).ConfigureAwait(false);
-
-            long deletedCount = 0;
-            DeleteResult res = null;
-
-            foreach (var batch in IDs.ToBatches(deleteBatchSize))
-            {
-                res = await DeleteCascadingAsync<T>(tenantPrefix, batch, session, cancellation).ConfigureAwait(false);
-                deletedCount += res.DeletedCount;
-            }
-
-            if (res?.IsAcknowledged == false)
-                return DeleteResult.Unacknowledged.Instance;
-
-            return new DeleteResult.Acknowledged(deletedCount);
+            return Context.DeleteAsync<T>(IDs, cancellation);
         }
 
         /// <summary>
@@ -116,13 +43,11 @@ public static async Task<DeleteResult> DeleteAsync<T>(IEnumerable<string> IDs, I
         /// </summary>
         /// <typeparam name="T">Any class that implements IEntity</typeparam>
         /// <param name="expression">A lambda expression for matching entities to delete.</param>
-        /// <param name = "session" >An optional session if using within a transaction</param>
         /// <param name="cancellation">An optional cancellation token</param>
         /// <param name="collation">An optional collation object</param>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static Task<DeleteResult> DeleteAsync<T>(Expression<Func<T, bool>> expression, IClientSessionHandle session = null, CancellationToken cancellation = default, Collation collation = null, string tenantPrefix = null) where T : IEntity
+        public static Task<DeleteResult> DeleteAsync<T>(Expression<Func<T, bool>> expression, CancellationToken cancellation = default, Collation? collation = null) where T : IEntity
         {
-            return DeleteAsync(Builders<T>.Filter.Where(expression), session, cancellation, collation, tenantPrefix);
+            return Context.DeleteAsync(expression, collation: collation, cancellation: cancellation);
         }
 
         /// <summary>
@@ -132,13 +57,11 @@ public static Task<DeleteResult> DeleteAsync<T>(Expression<Func<T, bool>> expres
         /// </summary>
         /// <typeparam name="T">Any class that implements IEntity</typeparam>
         /// <param name="filter">f => f.Eq(x => x.Prop, Value) &amp; f.Gt(x => x.Prop, Value)</param>
-        /// <param name = "session" >An optional session if using within a transaction</param>
         /// <param name="cancellation">An optional cancellation token</param>
         /// <param name="collation">An optional collation object</param>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static Task<DeleteResult> DeleteAsync<T>(Func<FilterDefinitionBuilder<T>, FilterDefinition<T>> filter, IClientSessionHandle session = null, CancellationToken cancellation = default, Collation collation = null, string tenantPrefix = null) where T : IEntity
+        public static Task<DeleteResult> DeleteAsync<T>(Func<FilterDefinitionBuilder<T>, FilterDefinition<T>> filter, CancellationToken cancellation = default, Collation? collation = null) where T : IEntity
         {
-            return DeleteAsync(filter(Builders<T>.Filter), session, cancellation, collation, tenantPrefix);
+            return Context.DeleteAsync(filter, collation: collation, cancellation: cancellation);
         }
 
         /// <summary>
@@ -148,47 +71,11 @@ public static Task<DeleteResult> DeleteAsync<T>(Func<FilterDefinitionBuilder<T>,
         /// </summary>
         /// <typeparam name="T">Any class that implements IEntity</typeparam>
         /// <param name="filter">A filter definition for matching entities to delete.</param>
-        /// <param name = "session" >An optional session if using within a transaction</param>
         /// <param name="cancellation">An optional cancellation token</param>
         /// <param name="collation">An optional collation object</param>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static async Task<DeleteResult> DeleteAsync<T>(FilterDefinition<T> filter, IClientSessionHandle? session = null, CancellationToken cancellation = default, Collation? collation = null) where T : IEntity
-        {
-            ThrowIfCancellationNotSupported(session, cancellation);
-
-            var cursor = await new Find<T, string>(session, null, tenantPrefix)
-                               .Match(_ => filter)
-                               .Project(e => e.ID)
-                               .Option(o => o.BatchSize = deleteBatchSize)
-                               .Option(o => o.Collation = collation)
-                               .ExecuteCursorAsync(cancellation)
-                               .ConfigureAwait(false);
-
-            long deletedCount = 0;
-            DeleteResult res = null;
-
-            using (cursor)
-            {
-                while (await cursor.MoveNextAsync(cancellation).ConfigureAwait(false))
-                {
-                    if (cursor.Current.Any())
-                    {
-                        res = await DeleteCascadingAsync<T>(tenantPrefix, cursor.Current, session, cancellation).ConfigureAwait(false);
-                        deletedCount += res.DeletedCount;
-                    }
-                }
-            }
-
-            if (res?.IsAcknowledged == false)
-                return DeleteResult.Unacknowledged.Instance;
-
-            return new DeleteResult.Acknowledged(deletedCount);
-        }
-
-        private static void ThrowIfCancellationNotSupported(IClientSessionHandle session = null, CancellationToken cancellation = default)
+        public static Task<DeleteResult> DeleteAsync<T>(FilterDefinition<T> filter, CancellationToken cancellation = default, Collation? collation = null) where T : IEntity
         {
-            if (cancellation != default && session == null)
-                throw new NotSupportedException("Cancellation is only supported within transactions for delete operations!");
+            return Context.DeleteAsync(filter, collation: collation, cancellation: cancellation);
         }
     }
 }
diff --git a/MongoDB.Entities/DBContext/DBContext.Delete.cs b/MongoDB.Entities/DBContext/DBContext.Delete.cs
index cb46b46dd..e615a5831 100644
--- a/MongoDB.Entities/DBContext/DBContext.Delete.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Delete.cs
@@ -1,6 +1,7 @@
 using MongoDB.Driver;
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Linq.Expressions;
 using System.Threading;
 using System.Threading.Tasks;
@@ -9,6 +10,61 @@ namespace MongoDB.Entities
 {
     public partial class DBContext
     {
+        private static readonly int _deleteBatchSize = 100000;
+        private void ThrowIfCancellationNotSupported(CancellationToken cancellation = default)
+        {
+            if (cancellation != default && Session is null)
+                throw new NotSupportedException("Cancellation is only supported within transactions for delete operations!");
+        }
+
+        private async Task<DeleteResult> DeleteCascadingAsync<T>(IEnumerable<string> IDs, CancellationToken cancellation = default) where T : IEntity
+        {
+            // note: cancellation should not be enabled outside of transactions because multiple collections are involved 
+            //       and premature cancellation could cause data inconsistencies.
+            //       i.e. don't pass the cancellation token to delete methods below that don't take a session.
+            //       also make consumers call ThrowIfCancellationNotSupported() before calling this method.
+
+            var db = Database;
+            var options = new ListCollectionNamesOptions
+            {
+                Filter = "{$and:[{name:/~/},{name:/" + Cache<T>().CollectionName + "/}]}"
+            };
+
+            var tasks = new List<Task>();
+
+            // note: db.listCollections() mongo command does not support transactions.
+            //       so don't add session support here.
+            var collNamesCursor = await db.ListCollectionNamesAsync(options, cancellation).ConfigureAwait(false);
+
+            foreach (var cName in await collNamesCursor.ToListAsync(cancellation).ConfigureAwait(false))
+            {
+                tasks.Add(
+                    Session is null
+                    ? db.GetCollection<JoinRecord>(cName).DeleteManyAsync(r => IDs.Contains(r.ChildID) || IDs.Contains(r.ParentID))
+                    : db.GetCollection<JoinRecord>(cName).DeleteManyAsync(Session, r => IDs.Contains(r.ChildID) || IDs.Contains(r.ParentID), null, cancellation));
+            }
+
+            var delResTask =
+                    Session == null
+                    ? CollectionFor<T>().DeleteManyAsync(x => IDs.Contains(x.ID))
+                    : CollectionFor<T>().DeleteManyAsync(Session, x => IDs.Contains(x.ID), null, cancellation);
+
+            tasks.Add(delResTask);
+
+            if (typeof(T).BaseType == typeof(FileEntity))
+            {
+                tasks.Add(
+                    Session is null
+                    ? db.GetCollection<FileChunk>(Cache<FileChunk>().CollectionName).DeleteManyAsync(x => IDs.Contains(x.FileID))
+                    : db.GetCollection<FileChunk>(Cache<FileChunk>().CollectionName).DeleteManyAsync(Session, x => IDs.Contains(x.FileID), null, cancellation));
+            }
+
+            await Task.WhenAll(tasks).ConfigureAwait(false);
+
+            return await delResTask.ConfigureAwait(false);
+        }
+
+
         /// <summary>
         /// Deletes a single entity from MongoDB
         /// <para>HINT: If this entity is referenced by one-to-many/many-to-many relationships, those references are also deleted.</para>
@@ -19,10 +75,7 @@ public partial class DBContext
         /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
         public Task<DeleteResult> DeleteAsync<T>(string ID, CancellationToken cancellation = default, bool ignoreGlobalFilters = false) where T : IEntity
         {
-            return DB.DeleteAsync(
-                Logic.MergeWithGlobalFilter(ignoreGlobalFilters, _globalFilters, Builders<T>.Filter.Eq(e => e.ID, ID)),
-                Session,
-                cancellation);
+            return DeleteAsync(Builders<T>.Filter.Eq(e => e.ID, ID), cancellation, ignoreGlobalFilters: ignoreGlobalFilters);
         }
 
         /// <summary>
@@ -36,11 +89,7 @@ public Task<DeleteResult> DeleteAsync<T>(string ID, CancellationToken cancellati
         /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
         public Task<DeleteResult> DeleteAsync<T>(IEnumerable<string> IDs, CancellationToken cancellation = default, bool ignoreGlobalFilters = false) where T : IEntity
         {
-            return DB.DeleteAsync(
-                Logic.MergeWithGlobalFilter(ignoreGlobalFilters, _globalFilters, Builders<T>.Filter.In(e => e.ID, IDs)),
-                Session,
-                cancellation,
-                tenantPrefix: tenantPrefix);
+            return DeleteAsync(Builders<T>.Filter.In(e => e.ID, IDs), cancellation, ignoreGlobalFilters: ignoreGlobalFilters);
         }
 
         /// <summary>
@@ -53,14 +102,9 @@ public Task<DeleteResult> DeleteAsync<T>(IEnumerable<string> IDs, CancellationTo
         /// <param name="cancellation">An optional cancellation token</param>
         /// <param name="collation">An optional collation object</param>
         /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
-        public Task<DeleteResult> DeleteAsync<T>(Expression<Func<T, bool>> expression, CancellationToken cancellation = default, Collation collation = null, bool ignoreGlobalFilters = false) where T : IEntity
+        public Task<DeleteResult> DeleteAsync<T>(Expression<Func<T, bool>> expression, CancellationToken cancellation = default, Collation? collation = null, bool ignoreGlobalFilters = false) where T : IEntity
         {
-            return DB.DeleteAsync(
-                Logic.MergeWithGlobalFilter(ignoreGlobalFilters, _globalFilters, Builders<T>.Filter.Where(expression)),
-                Session,
-                cancellation,
-                collation,
-                tenantPrefix);
+            return DeleteAsync(Builders<T>.Filter.Where(expression), cancellation, collation, ignoreGlobalFilters);
         }
 
         /// <summary>
@@ -73,14 +117,9 @@ public Task<DeleteResult> DeleteAsync<T>(Expression<Func<T, bool>> expression, C
         /// <param name="cancellation">An optional cancellation token</param>
         /// <param name="collation">An optional collation object</param>
         /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
-        public Task<DeleteResult> DeleteAsync<T>(Func<FilterDefinitionBuilder<T>, FilterDefinition<T>> filter, CancellationToken cancellation = default, Collation collation = null, bool ignoreGlobalFilters = false) where T : IEntity
+        public Task<DeleteResult> DeleteAsync<T>(Func<FilterDefinitionBuilder<T>, FilterDefinition<T>> filter, CancellationToken cancellation = default, Collation? collation = null, bool ignoreGlobalFilters = false) where T : IEntity
         {
-            return DB.DeleteAsync(
-                Logic.MergeWithGlobalFilter(ignoreGlobalFilters, _globalFilters, filter(Builders<T>.Filter)),
-                Session,
-                cancellation,
-                collation,
-                tenantPrefix);
+            return DeleteAsync(filter(Builders<T>.Filter), cancellation, collation, ignoreGlobalFilters);
         }
 
         /// <summary>
@@ -93,14 +132,38 @@ public Task<DeleteResult> DeleteAsync<T>(Func<FilterDefinitionBuilder<T>, Filter
         /// <param name="cancellation">An optional cancellation token</param>
         /// <param name="collation">An optional collation object</param>
         /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
-        public Task<DeleteResult> DeleteAsync<T>(FilterDefinition<T> filter, CancellationToken cancellation = default, Collation collation = null, bool ignoreGlobalFilters = false) where T : IEntity
+        public async Task<DeleteResult> DeleteAsync<T>(FilterDefinition<T> filter, CancellationToken cancellation = default, Collation? collation = null, bool ignoreGlobalFilters = false) where T : IEntity
         {
-            return DB.DeleteAsync(
-                Logic.MergeWithGlobalFilter(ignoreGlobalFilters, _globalFilters, filter),
-                Session,
-                cancellation,
-                collation,
-                tenantPrefix);
+            ThrowIfCancellationNotSupported(cancellation);
+
+            var filterDef = Logic.MergeWithGlobalFilter(ignoreGlobalFilters, _globalFilters, filter);
+            var cursor = await new Find<T, string>(this, CollectionFor<T>(), GlobalFilters)
+                               .Match(filter)
+                               .Project(e => e.ID)
+                               .Option(o => o.BatchSize = _deleteBatchSize)
+                               .Option(o => o.Collation = collation)
+                               .ExecuteCursorAsync(cancellation)
+                               .ConfigureAwait(false);
+
+            long deletedCount = 0;
+            DeleteResult? res = null;
+
+            using (cursor)
+            {
+                while (await cursor.MoveNextAsync(cancellation).ConfigureAwait(false))
+                {
+                    if (cursor.Current.Any())
+                    {
+                        res = await DeleteCascadingAsync<T>(cursor.Current, cancellation).ConfigureAwait(false);
+                        deletedCount += res.DeletedCount;
+                    }
+                }
+            }
+
+            if (res?.IsAcknowledged == false)
+                return DeleteResult.Unacknowledged.Instance;
+
+            return new DeleteResult.Acknowledged(deletedCount);
         }
     }
 }

From 936633a1165c72027684da580ab8e7822aba3b41 Mon Sep 17 00:00:00 2001
From: Ahmed Fwela <ahmednfwela@bdaya-dev.com>
Date: Tue, 9 Nov 2021 19:00:53 +0200
Subject: [PATCH 13/26] reworked builders

---
 MongoDB.Entities/Builders/Distinct.cs         |  3 +-
 MongoDB.Entities/Builders/FilterQueryBase.cs  |  2 +-
 MongoDB.Entities/Builders/Find.cs             |  6 +--
 MongoDB.Entities/Builders/PagedSearch.cs      |  7 ++--
 MongoDB.Entities/Builders/Replace.cs          | 18 ++++-----
 .../Builders/SortFilterQueryBase.cs           |  3 +-
 MongoDB.Entities/Builders/Update.cs           | 37 +++++++++++--------
 MongoDB.Entities/Builders/UpdateAndGet.cs     | 26 +++++++------
 .../DBContext/DBContext.Delete.cs             |  2 +-
 .../DBContext/DBContext.Distinct.cs           |  2 +-
 MongoDB.Entities/DBContext/DBContext.cs       |  2 +-
 11 files changed, 56 insertions(+), 52 deletions(-)

diff --git a/MongoDB.Entities/Builders/Distinct.cs b/MongoDB.Entities/Builders/Distinct.cs
index 9c134bc79..9f4f63577 100644
--- a/MongoDB.Entities/Builders/Distinct.cs
+++ b/MongoDB.Entities/Builders/Distinct.cs
@@ -77,8 +77,7 @@ internal Distinct(
         }
         internal Distinct(
             DBContext context,
-            IMongoCollection<T> collection,
-            Dictionary<Type, (object filterDef, bool prepend)> globalFilters) : base(globalFilters: globalFilters)
+            IMongoCollection<T> collection) : base(globalFilters: context.GlobalFilters)
         {
             Context = context;
             Collection = collection;
diff --git a/MongoDB.Entities/Builders/FilterQueryBase.cs b/MongoDB.Entities/Builders/FilterQueryBase.cs
index 6b82e93c9..ece5a1c99 100644
--- a/MongoDB.Entities/Builders/FilterQueryBase.cs
+++ b/MongoDB.Entities/Builders/FilterQueryBase.cs
@@ -5,7 +5,7 @@
 using System.Linq.Expressions;
 namespace MongoDB.Entities
 {
-    public class FilterQueryBase<T, TSelf> where T : IEntity where TSelf : FilterQueryBase<T, TSelf>
+    public abstract class FilterQueryBase<T, TSelf> where T : IEntity where TSelf : FilterQueryBase<T, TSelf>
     {
         internal FilterDefinition<T> _filter = Builders<T>.Filter.Empty;
         internal Dictionary<Type, (object filterDef, bool prepend)> _globalFilters;
diff --git a/MongoDB.Entities/Builders/Find.cs b/MongoDB.Entities/Builders/Find.cs
index 13ccc3faf..77a45df25 100644
--- a/MongoDB.Entities/Builders/Find.cs
+++ b/MongoDB.Entities/Builders/Find.cs
@@ -158,8 +158,8 @@ public TSelf SortByTextScore(Expression<Func<T, object>>? scoreProperty)
     /// <typeparam name="T">Any class that implements IEntity</typeparam>
     public class Find<T> : Find<T, T> where T : IEntity
     {
-        internal Find(DBContext context, IMongoCollection<T> collection, Dictionary<Type, (object filterDef, bool prepend)> globalFilters)
-            : base(context, collection, globalFilters) { }
+        internal Find(DBContext context, IMongoCollection<T> collection)
+            : base(context, collection) { }
 
         internal Find(DBContext context, IMongoCollection<T> collection, FindBase<T, T, Find<T, T>> baseQuery)
             : base(context, collection, baseQuery) { }
@@ -185,7 +185,7 @@ internal Find(DBContext context, IMongoCollection<T> collection, FindBase<T, TPr
             Context = context;
             Collection = collection;
         }
-        internal Find(DBContext context, IMongoCollection<T> collection, Dictionary<Type, (object filterDef, bool prepend)> globalFilters) : base(globalFilters)
+        internal Find(DBContext context, IMongoCollection<T> collection) : base(context.GlobalFilters)
         {
             Context = context;
             Collection = collection;
diff --git a/MongoDB.Entities/Builders/PagedSearch.cs b/MongoDB.Entities/Builders/PagedSearch.cs
index 140a050e4..760d4b24e 100644
--- a/MongoDB.Entities/Builders/PagedSearch.cs
+++ b/MongoDB.Entities/Builders/PagedSearch.cs
@@ -173,9 +173,8 @@ public TSelf Option(Action<AggregateOptions> option)
     public class PagedSearch<T> : PagedSearch<T, T> where T : IEntity
     {
         internal PagedSearch(
-            DBContext context, IMongoCollection<T> collection,
-            Dictionary<Type, (object filterDef, bool prepend)> globalFilters)
-        : base(context, collection, globalFilters) { }
+            DBContext context, IMongoCollection<T> collection)
+        : base(context, collection) { }
     }
 
     /// <summary>
@@ -189,7 +188,7 @@ public class PagedSearch<T, TProjection> : PagedSearchBase<T, TProjection, Paged
         public DBContext Context { get; set; }
         public IMongoCollection<T> Collection { get; set; }
 
-        internal PagedSearch(DBContext context, IMongoCollection<T> collection, Dictionary<Type, (object filterDef, bool prepend)> globalFilters) : base(globalFilters)
+        internal PagedSearch(DBContext context, IMongoCollection<T> collection) : base(context.GlobalFilters)
         {
             var type = typeof(TProjection);
             if (type.IsPrimitive || type.IsValueType || (type == typeof(string)))
diff --git a/MongoDB.Entities/Builders/Replace.cs b/MongoDB.Entities/Builders/Replace.cs
index fe25a2044..29004d5c7 100644
--- a/MongoDB.Entities/Builders/Replace.cs
+++ b/MongoDB.Entities/Builders/Replace.cs
@@ -29,13 +29,12 @@ internal Replace(
             DBContext context,
             IMongoCollection<T> collection,
             ModifiedBy modifiedBy,
-            Dictionary<Type, (object filterDef, bool prepend)> globalFilters,
-            Action<T> onSaveAction) : base(globalFilters)
+            Action<T> onSaveAction) : base(context.GlobalFilters)
         {
             Context = context;
             Collection = collection;
-            this._modifiedBy = modifiedBy;
-            this._onSaveAction = onSaveAction;
+            _modifiedBy = modifiedBy;
+            _onSaveAction = onSaveAction;
         }
 
 
@@ -51,7 +50,7 @@ public Replace<T> WithEntity(T entity)
 
             _onSaveAction?.Invoke(entity);
 
-            this._entity = entity;
+            _entity = entity;
             return this;
         }
 
@@ -125,12 +124,13 @@ public async Task<ReplaceOneResult> ExecuteAsync(CancellationToken cancellation
 
         private void SetModOnAndByValues()
         {
-            if (Cache<T>.Instance.HasModifiedOn && _entity is IModifiedOn _entityModifiedOn) _entityModifiedOn.ModifiedOn = DateTime.UtcNow;
-            if (Cache<T>.Instance.ModifiedByProp != null && _modifiedBy != null)
+            var cache = Context.Cache<T>();
+            if (cache.HasModifiedOn && _entity is IModifiedOn _entityModifiedOn) _entityModifiedOn.ModifiedOn = DateTime.UtcNow;
+            if (cache.ModifiedByProp != null && _modifiedBy != null)
             {
-                Cache<T>.Instance.ModifiedByProp.SetValue(
+                cache.ModifiedByProp.SetValue(
                     _entity,
-                    BsonSerializer.Deserialize(_modifiedBy.ToBson(), Cache<T>.Instance.ModifiedByProp.PropertyType));
+                    BsonSerializer.Deserialize(_modifiedBy.ToBson(), cache.ModifiedByProp.PropertyType));
             }
         }
     }
diff --git a/MongoDB.Entities/Builders/SortFilterQueryBase.cs b/MongoDB.Entities/Builders/SortFilterQueryBase.cs
index f127f8f0a..08eb7d9ab 100644
--- a/MongoDB.Entities/Builders/SortFilterQueryBase.cs
+++ b/MongoDB.Entities/Builders/SortFilterQueryBase.cs
@@ -5,7 +5,7 @@
 #nullable enable
 namespace MongoDB.Entities
 {
-    public class SortFilterQueryBase<T, TSelf> : FilterQueryBase<T, TSelf> where T : IEntity where TSelf : SortFilterQueryBase<T, TSelf>
+    public abstract class SortFilterQueryBase<T, TSelf> : FilterQueryBase<T, TSelf> where T : IEntity where TSelf : SortFilterQueryBase<T, TSelf>
     {
         internal List<SortDefinition<T>> _sorts = new();
         private TSelf This => (TSelf)this;
@@ -16,7 +16,6 @@ internal SortFilterQueryBase(SortFilterQueryBase<T, TSelf> other) : base(other)
         }
         internal SortFilterQueryBase(Dictionary<Type, (object filterDef, bool prepend)> globalFilters) : base(globalFilters: globalFilters)
         {
-            _globalFilters = globalFilters;
         }
 
 
diff --git a/MongoDB.Entities/Builders/Update.cs b/MongoDB.Entities/Builders/Update.cs
index 6498f1910..35c43fdfd 100644
--- a/MongoDB.Entities/Builders/Update.cs
+++ b/MongoDB.Entities/Builders/Update.cs
@@ -9,11 +9,13 @@
 
 namespace MongoDB.Entities
 {
-    public class UpdateBase<T, TSelf> : FilterQueryBase<T, TSelf> where T : IEntity where TSelf : UpdateBase<T, TSelf>
+    public abstract class UpdateBase<T, TSelf> : FilterQueryBase<T, TSelf> where T : IEntity where TSelf : UpdateBase<T, TSelf>
     {
         protected readonly List<UpdateDefinition<T>> defs;
         protected readonly Action<TSelf>? onUpdateAction;
 
+        internal abstract Cache<T> Cache();
+
         internal UpdateBase(UpdateBase<T, TSelf> other) : base(other)
         {
             onUpdateAction = other.onUpdateAction;
@@ -62,7 +64,7 @@ public void AddModification(Template template)
         {
             AddModification(template.RenderToString());
         }
-   
+
 
         /// <summary>
         /// Specify the property and it's value to modify (use multiple times if needed)
@@ -112,7 +114,8 @@ public TSelf Modify(Template template)
         /// <param name="entity">The entity instance to read the property values from</param>
         public TSelf ModifyWith(T entity)
         {
-            if (Cache<T>.Instance.HasModifiedOn) ((IModifiedOn)entity).ModifiedOn = DateTime.UtcNow;
+
+            if (Cache().HasModifiedOn) ((IModifiedOn)entity).ModifiedOn = DateTime.UtcNow;
             defs.AddRange(Logic.BuildUpdateDefs(entity));
             return This;
         }
@@ -124,7 +127,7 @@ public TSelf ModifyWith(T entity)
         /// <param name="entity">The entity instance to read the corresponding values from</param>
         public TSelf ModifyOnly(Expression<Func<T, object>> members, T entity)
         {
-            if (Cache<T>.Instance.HasModifiedOn) ((IModifiedOn)entity).ModifiedOn = DateTime.UtcNow;
+            if (Cache().HasModifiedOn) ((IModifiedOn)entity).ModifiedOn = DateTime.UtcNow;
             defs.AddRange(Logic.BuildUpdateDefs(entity, members));
             return This;
         }
@@ -136,7 +139,7 @@ public TSelf ModifyOnly(Expression<Func<T, object>> members, T entity)
         /// <param name="entity">The entity instance to read the corresponding values from</param>
         public TSelf ModifyExcept(Expression<Func<T, object>> members, T entity)
         {
-            if (Cache<T>.Instance.HasModifiedOn) ((IModifiedOn)entity).ModifiedOn = DateTime.UtcNow;
+            if (Cache().HasModifiedOn) ((IModifiedOn)entity).ModifiedOn = DateTime.UtcNow;
             defs.AddRange(Logic.BuildUpdateDefs(entity, members, excludeMode: true));
             return This;
         }
@@ -159,7 +162,7 @@ internal Update(DBContext context, IMongoCollection<T> collection, UpdateBase<T,
             Collection = collection;
         }
 
-        internal Update(DBContext context, IMongoCollection<T> collection, Dictionary<Type, (object filterDef, bool prepend)> globalFilters, Action<Update<T>>? onUpdateAction, List<UpdateDefinition<T>>? defs = null) : base(globalFilters, onUpdateAction, defs)
+        internal Update(DBContext context, IMongoCollection<T> collection, Action<Update<T>>? onUpdateAction, List<UpdateDefinition<T>>? defs = null) : base(context.GlobalFilters, onUpdateAction, defs)
         {
             Context = context;
             Collection = collection;
@@ -169,6 +172,8 @@ internal Update(DBContext context, IMongoCollection<T> collection, Dictionary<Ty
         public IMongoCollection<T> Collection { get; }
 
 
+        private Cache<T>? _cache;
+        internal override Cache<T> Cache() => _cache ??= Context.Cache<T>();
 
 
 
@@ -273,7 +278,7 @@ public Update<T> AddToQueue()
             var mergedFilter = MergedFilter;
             if (mergedFilter == Builders<T>.Filter.Empty) throw new ArgumentException("Please use Match() method first!");
             if (defs.Count == 0) throw new ArgumentException("Please use Modify() method first!");
-            if (Cache<T>.Instance.HasModifiedOn) Modify(b => b.CurrentDate(Cache<T>.Instance.ModifiedOnPropName));
+            if (Cache().HasModifiedOn) Modify(b => b.CurrentDate(Cache().ModifiedOnPropName));
             onUpdateAction?.Invoke(this);
             _models.Add(new UpdateManyModel<T>(mergedFilter, Builders<T>.Update.Combine(defs))
             {
@@ -315,10 +320,10 @@ public async Task<UpdateResult> ExecuteAsync(CancellationToken cancellation = de
                 if (mergedFilter == Builders<T>.Filter.Empty) throw new ArgumentException("Please use Match() method first!");
                 if (defs.Count == 0) throw new ArgumentException("Please use a Modify() method first!");
                 if (_stages.Count > 0) throw new ArgumentException("Regular updates and Pipeline updates cannot be used together!");
-                if (ShouldSetModDate()) Modify(b => b.CurrentDate(Cache<T>.Instance.ModifiedOnPropName));
+                if (ShouldSetModDate()) Modify(b => b.CurrentDate(Cache().ModifiedOnPropName));
 
                 onUpdateAction?.Invoke(this);
-                return await UpdateAsync(mergedFilter, Builders<T>.Update.Combine(defs), _options, this.Session(), cancellation).ConfigureAwait(false);
+                return await UpdateAsync(mergedFilter, Builders<T>.Update.Combine(defs), _options, cancellation).ConfigureAwait(false);
             }
         }
 
@@ -332,13 +337,12 @@ public Task<UpdateResult> ExecutePipelineAsync(CancellationToken cancellation =
             if (mergedFilter == Builders<T>.Filter.Empty) throw new ArgumentException("Please use Match() method first!");
             if (_stages.Count == 0) throw new ArgumentException("Please use WithPipelineStage() method first!");
             if (defs.Count > 0) throw new ArgumentException("Pipeline updates cannot be used together with regular updates!");
-            if (ShouldSetModDate()) WithPipelineStage($"{{ $set: {{ '{Cache<T>.Instance.ModifiedOnPropName}': new Date() }} }}");
+            if (ShouldSetModDate()) WithPipelineStage($"{{ $set: {{ '{Cache().ModifiedOnPropName}': new Date() }} }}");
 
             return UpdateAsync(
                 mergedFilter,
                 Builders<T>.Update.Pipeline(_stages.ToArray()),
                 _options,
-                this.Session(),
                 cancellation);
         }
 
@@ -347,18 +351,19 @@ private bool ShouldSetModDate()
             //only set mod date by library if user hasn't done anything with the ModifiedOn property
 
             return
-                Cache<T>.Instance.HasModifiedOn &&
+                Cache().HasModifiedOn &&
                 !defs.Any(d => d
                        .Render(BsonSerializer.SerializerRegistry.GetSerializer<T>(), BsonSerializer.SerializerRegistry)
                        .ToString()
-                       .Contains($"\"{Cache<T>.Instance.ModifiedOnPropName}\""));
+                       .Contains($"\"{Cache().ModifiedOnPropName}\""));
         }
 
-        private Task<UpdateResult> UpdateAsync(FilterDefinition<T> filter, UpdateDefinition<T> definition, UpdateOptions options, IClientSessionHandle? session = null, CancellationToken cancellation = default)
+        private Task<UpdateResult> UpdateAsync(FilterDefinition<T> filter, UpdateDefinition<T> definition, UpdateOptions options, CancellationToken cancellation = default)
         {
-            return session == null
+            return Context.Session is null
                    ? Collection.UpdateManyAsync(filter, definition, options, cancellation)
-                   : Collection.UpdateManyAsync(session, filter, definition, options, cancellation);
+                   : Collection.UpdateManyAsync(Context.Session, filter, definition, options, cancellation);
         }
+
     }
 }
diff --git a/MongoDB.Entities/Builders/UpdateAndGet.cs b/MongoDB.Entities/Builders/UpdateAndGet.cs
index 54364c986..5f32d46d2 100644
--- a/MongoDB.Entities/Builders/UpdateAndGet.cs
+++ b/MongoDB.Entities/Builders/UpdateAndGet.cs
@@ -20,7 +20,7 @@ internal UpdateAndGet(DBContext context, IMongoCollection<T> collection, UpdateB
         {
         }
 
-        internal UpdateAndGet(DBContext context, IMongoCollection<T> collection, Dictionary<Type, (object filterDef, bool prepend)> globalFilters, Action<UpdateAndGet<T, T>>? onUpdateAction, List<UpdateDefinition<T>>? defs) : base(context, collection, globalFilters, onUpdateAction, defs)
+        internal UpdateAndGet(DBContext context, IMongoCollection<T> collection, Action<UpdateAndGet<T, T>>? onUpdateAction, List<UpdateDefinition<T>>? defs) : base(context, collection, onUpdateAction, defs)
         {
         }
     }
@@ -45,13 +45,14 @@ internal UpdateAndGet(DBContext context, IMongoCollection<T> collection, UpdateB
             Collection = collection;
         }
 
-        internal UpdateAndGet(DBContext context, IMongoCollection<T> collection, Dictionary<Type, (object filterDef, bool prepend)> globalFilters, Action<UpdateAndGet<T, TProjection>>? onUpdateAction = null, List<UpdateDefinition<T>>? defs = null) : base(globalFilters, onUpdateAction, defs)
+        internal UpdateAndGet(DBContext context, IMongoCollection<T> collection, Action<UpdateAndGet<T, TProjection>>? onUpdateAction = null, List<UpdateDefinition<T>>? defs = null) : base(context.GlobalFilters, onUpdateAction, defs)
         {
             Context = context;
             Collection = collection;
         }
 
-
+        private Cache<T>? _cache;
+        internal override Cache<T> Cache() => _cache ??= Context.Cache<T>();
 
         /// <summary>
         /// Specify an update pipeline with multiple stages using a Template to modify the Entities.
@@ -170,7 +171,7 @@ public UpdateAndGet<T, TProjection> IncludeRequiredProps()
             if (typeof(T) != typeof(TProjection))
                 throw new InvalidOperationException("IncludeRequiredProps() cannot be used when projecting to a different type.");
 
-            _options.Projection = Cache<T>.Instance.CombineWithRequiredProps(_options.Projection);
+            _options.Projection = Cache().CombineWithRequiredProps(_options.Projection);
             return this;
         }
 
@@ -184,9 +185,9 @@ public async Task<TProjection> ExecuteAsync(CancellationToken cancellation = def
             if (mergedFilter == Builders<T>.Filter.Empty) throw new ArgumentException("Please use Match() method first!");
             if (defs.Count == 0) throw new ArgumentException("Please use Modify() method first!");
             if (_stages.Count > 0) throw new ArgumentException("Regular updates and Pipeline updates cannot be used together!");
-            if (ShouldSetModDate()) Modify(b => b.CurrentDate(Cache<T>.Instance.ModifiedOnPropName));
+            if (ShouldSetModDate()) Modify(b => b.CurrentDate(Cache().ModifiedOnPropName));
             onUpdateAction?.Invoke(this);
-            return await UpdateAndGetAsync(mergedFilter, Builders<T>.Update.Combine(defs), _options, this.Session(), cancellation).ConfigureAwait(false);
+            return await UpdateAndGetAsync(mergedFilter, Builders<T>.Update.Combine(defs), _options, cancellation).ConfigureAwait(false);
         }
 
         /// <summary>
@@ -199,10 +200,10 @@ public Task<TProjection> ExecutePipelineAsync(CancellationToken cancellation = d
             if (mergedFilter == Builders<T>.Filter.Empty) throw new ArgumentException("Please use Match() method first!");
             if (_stages.Count == 0) throw new ArgumentException("Please use WithPipelineStage() method first!");
             if (defs.Count > 0) throw new ArgumentException("Pipeline updates cannot be used together with regular updates!");
-            if (ShouldSetModDate()) WithPipelineStage($"{{ $set: {{ '{Cache<T>.Instance.ModifiedOnPropName}': new Date() }} }}");
+            if (ShouldSetModDate()) WithPipelineStage($"{{ $set: {{ '{Cache().ModifiedOnPropName}': new Date() }} }}");
 
 
-            return UpdateAndGetAsync(mergedFilter, Builders<T>.Update.Pipeline(_stages.ToArray()), _options, this.Session(), cancellation);
+            return UpdateAndGetAsync(mergedFilter, Builders<T>.Update.Pipeline(_stages.ToArray()), _options, cancellation);
         }
 
         private bool ShouldSetModDate()
@@ -210,18 +211,19 @@ private bool ShouldSetModDate()
             //only set mod date by library if user hasn't done anything with the ModifiedOn property
 
             return
-                Cache<T>.Instance.HasModifiedOn &&
+                Cache().HasModifiedOn &&
                 !defs.Any(d => d
                        .Render(BsonSerializer.SerializerRegistry.GetSerializer<T>(), BsonSerializer.SerializerRegistry)
                        .ToString()
-                       .Contains($"\"{Cache<T>.Instance.ModifiedOnPropName}\""));
+                       .Contains($"\"{Cache().ModifiedOnPropName}\""));
         }
 
-        private Task<TProjection> UpdateAndGetAsync(FilterDefinition<T> filter, UpdateDefinition<T> definition, FindOneAndUpdateOptions<T, TProjection> options, IClientSessionHandle? session = null, CancellationToken cancellation = default)
+        private Task<TProjection> UpdateAndGetAsync(FilterDefinition<T> filter, UpdateDefinition<T> definition, FindOneAndUpdateOptions<T, TProjection> options, CancellationToken cancellation = default)
         {
-            return session == null
+            return Context.Session is not IClientSessionHandle session
                 ? Collection.FindOneAndUpdateAsync(filter, definition, options, cancellation)
                 : Collection.FindOneAndUpdateAsync(session, filter, definition, options, cancellation);
         }
+
     }
 }
diff --git a/MongoDB.Entities/DBContext/DBContext.Delete.cs b/MongoDB.Entities/DBContext/DBContext.Delete.cs
index e615a5831..b8800ebf6 100644
--- a/MongoDB.Entities/DBContext/DBContext.Delete.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Delete.cs
@@ -137,7 +137,7 @@ public async Task<DeleteResult> DeleteAsync<T>(FilterDefinition<T> filter, Cance
             ThrowIfCancellationNotSupported(cancellation);
 
             var filterDef = Logic.MergeWithGlobalFilter(ignoreGlobalFilters, _globalFilters, filter);
-            var cursor = await new Find<T, string>(this, CollectionFor<T>(), GlobalFilters)
+            var cursor = await new Find<T, string>(this, CollectionFor<T>())
                                .Match(filter)
                                .Project(e => e.ID)
                                .Option(o => o.BatchSize = _deleteBatchSize)
diff --git a/MongoDB.Entities/DBContext/DBContext.Distinct.cs b/MongoDB.Entities/DBContext/DBContext.Distinct.cs
index c6eaa71a8..3beaa8437 100644
--- a/MongoDB.Entities/DBContext/DBContext.Distinct.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Distinct.cs
@@ -9,7 +9,7 @@ public partial class DBContext
         /// <typeparam name="TProperty">The type of the property of the entity you'd like to get unique values for</typeparam>
         public Distinct<T, TProperty> Distinct<T, TProperty>() where T : IEntity
         {
-            return new Distinct<T, TProperty>(Session, _globalFilters, tenantPrefix);
+            return new Distinct<T, TProperty>(this, CollectionFor<T>());
         }
     }
 }
diff --git a/MongoDB.Entities/DBContext/DBContext.cs b/MongoDB.Entities/DBContext/DBContext.cs
index 3c4409cb7..f5b2e08c2 100644
--- a/MongoDB.Entities/DBContext/DBContext.cs
+++ b/MongoDB.Entities/DBContext/DBContext.cs
@@ -48,7 +48,7 @@ public ModifiedBy? ModifiedBy
         public MongoDatabaseSettings Settings => Database.Settings;
 
         private Dictionary<Type, (object filterDef, bool prepend)>? _globalFilters;
-        private Dictionary<Type, (object filterDef, bool prepend)> GlobalFilters => _globalFilters ??= new();
+        internal Dictionary<Type, (object filterDef, bool prepend)> GlobalFilters => _globalFilters ??= new();
 
         /// <summary>
         /// Copy constructor

From 9595d38373696dbd54bc3bbf2f33252df240cd3b Mon Sep 17 00:00:00 2001
From: Ahmed Fwela <ahmednfwela@bdaya-dev.com>
Date: Tue, 9 Nov 2021 21:16:01 +0200
Subject: [PATCH 14/26] WIP insert

---
 MongoDB.Entities/Core/FileEntity.cs           | 201 +++++++++---------
 MongoDB.Entities/Core/GeoNear.cs              |  16 +-
 MongoDB.Entities/DB/DB.Fluent.cs              |  33 +--
 MongoDB.Entities/DB/DB.GeoNear.cs             |  19 +-
 MongoDB.Entities/DBContext/DBContext.File.cs  |   7 +-
 MongoDB.Entities/DBContext/DBContext.Find.cs  |   4 +-
 .../DBContext/DBContext.Fluent.cs             |  43 +++-
 .../DBContext/DBContext.GeoNear.cs            |  23 +-
 MongoDB.Entities/DBContext/DBContext.Index.cs |   2 +-
 .../DBContext/DBContext.Insert.cs             |   6 +-
 .../DBContext/DBContext.Pipeline.cs           |   8 +-
 MongoDB.Entities/DBContext/DBContext.Save.cs  |  33 ++-
 MongoDB.Entities/DBContext/DBContext.cs       |   9 +-
 13 files changed, 190 insertions(+), 214 deletions(-)

diff --git a/MongoDB.Entities/Core/FileEntity.cs b/MongoDB.Entities/Core/FileEntity.cs
index beb2dc732..6d6add2de 100644
--- a/MongoDB.Entities/Core/FileEntity.cs
+++ b/MongoDB.Entities/Core/FileEntity.cs
@@ -17,8 +17,6 @@ namespace MongoDB.Entities
     /// </summary>
     public abstract class FileEntity : Entity
     {
-        private DataStreamer streamer;
-
         /// <summary>
         /// The total amount of data in bytes that has been uploaded so far
         /// </summary>
@@ -41,25 +39,19 @@ public abstract class FileEntity : Entity
         /// If this value is set, the uploaded data will be hashed and matched against this value. If the hash is not equal, an exception will be thrown by the UploadAsync() method.
         /// </summary>
         [IgnoreDefault]
-        public string MD5 { get; set; }
-
-
-        /// <summary>
-        /// Access the DataStreamer class for uploading and downloading data
-        /// </summary>
-        public DataStreamer Data => streamer ??= new DataStreamer(this);
+        public string? MD5 { get; set; }
     }
 
     [Collection("[BINARY_CHUNKS]")]
     internal class FileChunk : IEntity
     {
         [BsonId, ObjectId]
-        public string ID { get; set; }
+        public string ID { get; set; } = null!;
 
         [AsObjectId]
-        public string FileID { get; set; }
+        public string FileID { get; set; } = null!;
 
-        public byte[] Data { get; set; }
+        public byte[] Data { get; set; } = Array.Empty<byte>();
 
         public string GenerateNewID()
             => ObjectId.GenerateNewId().ToString();
@@ -68,30 +60,28 @@ public string GenerateNewID()
     /// <summary>
     /// Provides the interface for uploading and downloading data chunks for file entities.
     /// </summary>
-    public class DataStreamer
+    public class DataStreamer<T> where T : FileEntity
     {
-        private static readonly HashSet<string> indexedDBs = new();
-
-        private readonly FileEntity parent;
-        private readonly Type parentType;
-        private readonly DBContext db;
-        private readonly IMongoCollection<FileChunk> chunkCollection;
-        private FileChunk doc;
-        private int chunkSize, readCount;
-        private byte[] buffer;
-        private List<byte> dataChunk;
-        private MD5 md5;
-
-        internal DataStreamer(FileEntity parent, DBContext db)
+        private static readonly HashSet<string> _indexedDBs = new();
+
+        private readonly T _parent;
+        private readonly DBContext _db;
+        private readonly IMongoCollection<FileChunk> _chunkCollection;
+        private FileChunk? _doc;
+        private int _chunkSize, _readCount;
+        private byte[]? _buffer;
+        private List<byte>? _dataChunk;
+        private MD5? _md5;
+
+        internal DataStreamer(T parent, DBContext db)
         {
-            this.parent = parent;
-            parentType = parent.GetType();
-            this.db = db;
-            chunkCollection = db.GetCollection<FileChunk>(DB.CollectionName<FileChunk>());
+            _parent = parent;
+            _db = db;
+            _chunkCollection = db.CollectionFor<FileChunk>();
 
-            if (indexedDBs.Add(db.DatabaseNamespace.DatabaseName))
+            if (_indexedDBs.Add(db.DatabaseNamespace.DatabaseName))
             {
-                _ = chunkCollection.Indexes.CreateOneAsync(
+                _ = _chunkCollection.Indexes.CreateOneAsync(
                     new CreateIndexModel<FileChunk>(
                         Builders<FileChunk>.IndexKeys.Ascending(c => c.FileID),
                         new CreateIndexOptions { Background = true, Name = $"{nameof(FileChunk.FileID)}(Asc)" }));
@@ -104,10 +94,9 @@ internal DataStreamer(FileEntity parent, DBContext db)
         /// <param name="stream">The output stream to write the data</param>
         /// <param name="timeOutSeconds">The maximum number of seconds allowed for the operation to complete</param>
         /// <param name="batchSize"></param>
-        /// <param name="session"></param>
-        public Task DownloadWithTimeoutAsync(Stream stream, int timeOutSeconds, int batchSize = 1, IClientSessionHandle session = null)
+        public Task DownloadWithTimeoutAsync(Stream stream, int timeOutSeconds, int batchSize = 1)
         {
-            return DownloadAsync(stream, batchSize, new CancellationTokenSource(timeOutSeconds * 1000).Token, session);
+            return DownloadAsync(stream, batchSize, new CancellationTokenSource(timeOutSeconds * 1000).Token);
         }
 
         /// <summary>
@@ -116,14 +105,13 @@ public Task DownloadWithTimeoutAsync(Stream stream, int timeOutSeconds, int batc
         /// <param name="stream">The output stream to write the data</param>
         /// <param name="batchSize">The number of chunks you want returned at once</param>
         /// <param name="cancellation">An optional cancellation token.</param>
-        /// <param name="session">An optional session if using within a transaction</param>
-        public async Task DownloadAsync(Stream stream, int batchSize = 1, CancellationToken cancellation = default, IClientSessionHandle session = null)
+        public async Task DownloadAsync(Stream stream, int batchSize = 1, CancellationToken cancellation = default)
         {
-            parent.ThrowIfUnsaved();
-            if (!parent.UploadSuccessful) throw new InvalidOperationException("Data for this file hasn't been uploaded successfully (yet)!");
+            _parent.ThrowIfUnsaved();
+            if (!_parent.UploadSuccessful) throw new InvalidOperationException("Data for this file hasn't been uploaded successfully (yet)!");
             if (!stream.CanWrite) throw new NotSupportedException("The supplied stream is not writable!");
 
-            var filter = Builders<FileChunk>.Filter.Eq(c => c.FileID, parent.ID);
+            var filter = Builders<FileChunk>.Filter.Eq(c => c.FileID, _parent.ID);
             var options = new FindOptions<FileChunk, byte[]>
             {
                 BatchSize = batchSize,
@@ -132,9 +120,9 @@ public async Task DownloadAsync(Stream stream, int batchSize = 1, CancellationTo
             };
 
             var findTask =
-                session == null
-                ? chunkCollection.FindAsync(filter, options, cancellation)
-                : chunkCollection.FindAsync(session, filter, options, cancellation);
+                _db.Session is not IClientSessionHandle session
+                ? _chunkCollection.FindAsync(filter, options, cancellation)
+                : _chunkCollection.FindAsync(session, filter, options, cancellation);
 
             using var cursor = await findTask.ConfigureAwait(false);
             var hasChunks = false;
@@ -148,7 +136,7 @@ public async Task DownloadAsync(Stream stream, int batchSize = 1, CancellationTo
                 }
             }
 
-            if (!hasChunks) throw new InvalidOperationException($"No data was found for file entity with ID: {parent.ID}");
+            if (!hasChunks) throw new InvalidOperationException($"No data was found for file entity with ID: {_parent.ID}");
         }
 
         /// <summary>
@@ -157,10 +145,9 @@ public async Task DownloadAsync(Stream stream, int batchSize = 1, CancellationTo
         /// <param name="stream">The input stream to read the data from</param>
         /// <param name="timeOutSeconds">The maximum number of seconds allowed for the operation to complete</param>
         /// <param name="chunkSizeKB">The 'average' size of one chunk in KiloBytes</param>
-        /// <param name="session">An optional session if using within a transaction</param>
-        public Task UploadWithTimeoutAsync(Stream stream, int timeOutSeconds, int chunkSizeKB = 256, IClientSessionHandle session = null)
+        public Task UploadWithTimeoutAsync(Stream stream, int timeOutSeconds, int chunkSizeKB = 256)
         {
-            return UploadAsync(stream, chunkSizeKB, new CancellationTokenSource(timeOutSeconds * 1000).Token, session);
+            return UploadAsync(stream, chunkSizeKB, new CancellationTokenSource(timeOutSeconds * 1000).Token);
         }
 
         /// <summary>
@@ -170,42 +157,41 @@ public Task UploadWithTimeoutAsync(Stream stream, int timeOutSeconds, int chunkS
         /// <param name="stream">The input stream to read the data from</param>
         /// <param name="chunkSizeKB">The 'average' size of one chunk in KiloBytes</param>
         /// <param name="cancellation">An optional cancellation token.</param>
-        /// <param name="session">An optional session if using within a transaction</param>
-        public async Task UploadAsync(Stream stream, int chunkSizeKB = 256, CancellationToken cancellation = default, IClientSessionHandle session = null)
+        public async Task UploadAsync(Stream stream, int chunkSizeKB = 256, CancellationToken cancellation = default)
         {
-            parent.ThrowIfUnsaved();
+            _parent.ThrowIfUnsaved();
             if (chunkSizeKB < 128 || chunkSizeKB > 4096) throw new ArgumentException("Please specify a chunk size from 128KB to 4096KB");
             if (!stream.CanRead) throw new NotSupportedException("The supplied stream is not readable!");
-            await CleanUpAsync(session).ConfigureAwait(false);
+            await CleanUpAsync().ConfigureAwait(false);
 
-            doc = new FileChunk { FileID = parent.ID };
-            chunkSize = chunkSizeKB * 1024;
-            dataChunk = new List<byte>(chunkSize);
-            buffer = new byte[64 * 1024]; // 64kb read buffer
-            readCount = 0;
+            _doc = new FileChunk { FileID = _parent.ID };
+            _chunkSize = chunkSizeKB * 1024;
+            _dataChunk = new List<byte>(_chunkSize);
+            _buffer = new byte[64 * 1024]; // 64kb read buffer
+            _readCount = 0;
 
-            if (!string.IsNullOrEmpty(parent.MD5))
-                md5 = MD5.Create();
+            if (!string.IsNullOrEmpty(_parent.MD5))
+                _md5 = MD5.Create();
 
             try
             {
                 if (stream.CanSeek && stream.Position > 0) stream.Position = 0;
 
-                while ((readCount = await stream.ReadAsync(buffer, 0, buffer.Length, cancellation).ConfigureAwait(false)) > 0)
+                while ((_readCount = await stream.ReadAsync(_buffer, 0, _buffer.Length, cancellation).ConfigureAwait(false)) > 0)
                 {
-                    md5?.TransformBlock(buffer, 0, readCount, null, 0);
-                    await FlushToDBAsync(session, isLastChunk: false, cancellation).ConfigureAwait(false);
+                    _md5?.TransformBlock(_buffer, 0, _readCount, null, 0);
+                    await FlushToDBAsync(isLastChunk: false, cancellation).ConfigureAwait(false);
                 }
 
-                if (parent.FileSize > 0)
+                if (_parent.FileSize > 0)
                 {
-                    md5?.TransformFinalBlock(buffer, 0, readCount);
-                    if (md5 != null && !BitConverter.ToString(md5.Hash).Replace("-", "").Equals(parent.MD5, StringComparison.OrdinalIgnoreCase))
+                    _md5?.TransformFinalBlock(_buffer, 0, _readCount);
+                    if (_md5 != null && !BitConverter.ToString(_md5.Hash).Replace("-", "").Equals(_parent.MD5, StringComparison.OrdinalIgnoreCase))
                     {
                         throw new InvalidDataException("MD5 of uploaded data doesn't match with file entity MD5.");
                     }
-                    await FlushToDBAsync(session, isLastChunk: true, cancellation).ConfigureAwait(false);
-                    parent.UploadSuccessful = true;
+                    await FlushToDBAsync(isLastChunk: true, cancellation).ConfigureAwait(false);
+                    _parent.UploadSuccessful = true;
                 }
                 else
                 {
@@ -214,77 +200,80 @@ public async Task UploadAsync(Stream stream, int chunkSizeKB = 256, Cancellation
             }
             catch (Exception)
             {
-                await CleanUpAsync(session).ConfigureAwait(false);
+                await CleanUpAsync().ConfigureAwait(false);
                 throw;
             }
             finally
             {
-                await UpdateMetaDataAsync(session).ConfigureAwait(false);
-                doc = null;
-                buffer = null;
-                dataChunk = null;
-                md5?.Dispose();
-                md5 = null;
+                await UpdateMetaDataAsync().ConfigureAwait(false);
+                _doc = null;
+                _buffer = null;
+                _dataChunk = null;
+                _md5?.Dispose();
+                _md5 = null;
             }
         }
 
         /// <summary>
         /// Deletes only the binary chunks stored in the database for this file entity.
         /// </summary>
-        /// <param name="session">An optional session if using within a transaction</param>
         /// <param name="cancellation">An optional cancellation token.</param>
-        public Task DeleteBinaryChunks(IClientSessionHandle session = null, CancellationToken cancellation = default)
+        public Task DeleteBinaryChunks(CancellationToken cancellation = default)
         {
-            parent.ThrowIfUnsaved();
+            _parent.ThrowIfUnsaved();
 
-            if (cancellation != default && session == null)
+            if (cancellation != default && _db.Session == null)
                 throw new NotSupportedException("Cancellation is only supported within transactions for deleting binary chunks!");
 
-            return CleanUpAsync(session, cancellation);
+            return CleanUpAsync(cancellation);
         }
 
-        private Task CleanUpAsync(IClientSessionHandle session, CancellationToken cancellation = default)
+        private Task CleanUpAsync(CancellationToken cancellation = default)
         {
-            parent.FileSize = 0;
-            parent.ChunkCount = 0;
-            parent.UploadSuccessful = false;
-            return session == null
-                   ? chunkCollection.DeleteManyAsync(c => c.FileID == parent.ID, cancellation)
-                   : chunkCollection.DeleteManyAsync(session, c => c.FileID == parent.ID, null, cancellation);
+            _parent.FileSize = 0;
+            _parent.ChunkCount = 0;
+            _parent.UploadSuccessful = false;
+            return _db.Session is not IClientSessionHandle session
+                   ? _chunkCollection.DeleteManyAsync(c => c.FileID == _parent.ID, cancellation)
+                   : _chunkCollection.DeleteManyAsync(session, c => c.FileID == _parent.ID, null, cancellation);
         }
 
-        private Task FlushToDBAsync(IClientSessionHandle session, bool isLastChunk = false, CancellationToken cancellation = default)
+        private Task FlushToDBAsync(bool isLastChunk = false, CancellationToken cancellation = default)
         {
             if (!isLastChunk)
             {
-                dataChunk.AddRange(new ArraySegment<byte>(buffer, 0, readCount));
-                parent.FileSize += readCount;
+                _dataChunk?.AddRange(new ArraySegment<byte>(_buffer, 0, _readCount));
+                _parent.FileSize += _readCount;
             }
-
-            if (dataChunk.Count >= chunkSize || isLastChunk)
+            if (_doc is null)
+            {
+                return Task.CompletedTask;
+            }
+            if (_dataChunk is not null && (_dataChunk.Count >= _chunkSize || isLastChunk))
             {
-                doc.ID = doc.GenerateNewID();
-                doc.Data = dataChunk.ToArray();
-                dataChunk.Clear();
-                parent.ChunkCount++;
-                return session == null
-                       ? chunkCollection.InsertOneAsync(doc, null, cancellation)
-                       : chunkCollection.InsertOneAsync(session, doc, null, cancellation);
+
+                _doc.ID = _doc.GenerateNewID();
+                _doc.Data = _dataChunk.ToArray();
+                _dataChunk.Clear();
+                _parent.ChunkCount++;
+                return _db.Session is not IClientSessionHandle session
+                       ? _chunkCollection.InsertOneAsync(_doc, null, cancellation)
+                       : _chunkCollection.InsertOneAsync(session, _doc, null, cancellation);
             }
 
             return Task.CompletedTask;
         }
 
-        private Task UpdateMetaDataAsync(IClientSessionHandle session)
+        private Task UpdateMetaDataAsync()
         {
-            var collection = db.GetCollection<FileEntity>(Cache.CollectionNameFor(parentType));
-            var filter = Builders<FileEntity>.Filter.Eq(e => e.ID, parent.ID);
-            var update = Builders<FileEntity>.Update
-                            .Set(e => e.FileSize, parent.FileSize)
-                            .Set(e => e.ChunkCount, parent.ChunkCount)
-                            .Set(e => e.UploadSuccessful, parent.UploadSuccessful);
-
-            return session == null
+            var collection = _db.CollectionFor<T>();
+            var filter = Builders<T>.Filter.Eq(e => e.ID, _parent.ID);
+            var update = Builders<T>.Update
+                            .Set(e => e.FileSize, _parent.FileSize)
+                            .Set(e => e.ChunkCount, _parent.ChunkCount)
+                            .Set(e => e.UploadSuccessful, _parent.UploadSuccessful);
+
+            return _db.Session is not IClientSessionHandle session
                    ? collection.UpdateOneAsync(filter, update)
                    : collection.UpdateOneAsync(session, filter, update);
         }
diff --git a/MongoDB.Entities/Core/GeoNear.cs b/MongoDB.Entities/Core/GeoNear.cs
index 20e37b383..441567be3 100644
--- a/MongoDB.Entities/Core/GeoNear.cs
+++ b/MongoDB.Entities/Core/GeoNear.cs
@@ -50,24 +50,24 @@ public class GeoNear<T> where T : IEntity
     {
 #pragma warning disable IDE1006
         public Coordinates2D near { get; set; }
-        public string distanceField { get; set; }
+        public string? distanceField { get; set; }
         public bool spherical { get; set; }
         [BsonIgnoreIfNull] public int? limit { get; set; }
         [BsonIgnoreIfNull] public double? maxDistance { get; set; }
-        [BsonIgnoreIfNull] public BsonDocument query { get; set; }
+        [BsonIgnoreIfNull] public BsonDocument? query { get; set; }
         [BsonIgnoreIfNull] public double? distanceMultiplier { get; set; }
-        [BsonIgnoreIfNull] public string includeLocs { get; set; }
+        [BsonIgnoreIfNull] public string? includeLocs { get; set; }
         [BsonIgnoreIfNull] public double? minDistance { get; set; }
-        [BsonIgnoreIfNull] public string key { get; set; }
+        [BsonIgnoreIfNull] public string? key { get; set; }
 #pragma warning restore IDE1006
 
-        internal IAggregateFluent<T> ToFluent(string tenantPrefix, AggregateOptions options = null, IClientSessionHandle session = null)
+        internal IAggregateFluent<T> ToFluent(DBContext context, AggregateOptions? options = null)
         {
             var stage = new BsonDocument { { "$geoNear", this.ToBsonDocument() } };
 
-            return session == null
-                    ? DB.Collection<T>(tenantPrefix).Aggregate(options).AppendStage<T>(stage)
-                    : DB.Collection<T>(tenantPrefix).Aggregate(session, options).AppendStage<T>(stage);
+            return context.Session == null
+                    ? context.CollectionFor<T>().Aggregate(options).AppendStage<T>(stage)
+                    : context.CollectionFor<T>().Aggregate(context.Session, options).AppendStage<T>(stage);
         }
     }
 }
diff --git a/MongoDB.Entities/DB/DB.Fluent.cs b/MongoDB.Entities/DB/DB.Fluent.cs
index 423afcfdd..1cd48f3ad 100644
--- a/MongoDB.Entities/DB/DB.Fluent.cs
+++ b/MongoDB.Entities/DB/DB.Fluent.cs
@@ -9,13 +9,9 @@ public static partial class DB
         /// </summary>
         /// <typeparam name="T">Any class that implements IEntity</typeparam>
         /// <param name="options">The options for the aggregation. This is not required.</param>
-        /// <param name="session">An optional session if using within a transaction</param>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static IAggregateFluent<T> Fluent<T>(AggregateOptions options = null, IClientSessionHandle session = null, string tenantPrefix = null) where T : IEntity
+        public static IAggregateFluent<T> Fluent<T>(AggregateOptions? options = null) where T : IEntity
         {
-            return session == null
-                   ? Collection<T>(tenantPrefix).Aggregate(options)
-                   : Collection<T>(tenantPrefix).Aggregate(session, options);
+            return Context.Fluent<T>(options);
         }
 
         /// <summary>
@@ -28,30 +24,9 @@ public static IAggregateFluent<T> Fluent<T>(AggregateOptions options = null, ICl
         /// <param name="diacriticSensitive">Diacritic sensitivity of the search (optional)</param>
         /// <param name="language">The language for the search (optional)</param>
         /// <param name="options">Options for finding documents (not required)</param>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        /// <param name="session">An optional session if using within a transaction</param>
-        public static IAggregateFluent<T> FluentTextSearch<T>(Search searchType, string searchTerm, bool caseSensitive = false, bool diacriticSensitive = false, string language = null, AggregateOptions options = null, IClientSessionHandle session = null, string tenantPrefix = null) where T : IEntity
+        public static IAggregateFluent<T> FluentTextSearch<T>(Search searchType, string searchTerm, bool caseSensitive = false, bool diacriticSensitive = false, string? language = null, AggregateOptions? options = null) where T : IEntity
         {
-            if (searchType == Search.Fuzzy)
-            {
-                searchTerm = searchTerm.ToDoubleMetaphoneHash();
-                caseSensitive = false;
-                diacriticSensitive = false;
-                language = null;
-            }
-
-            var filter = Builders<T>.Filter.Text(
-                            searchTerm,
-                            new TextSearchOptions
-                            {
-                                CaseSensitive = caseSensitive,
-                                DiacriticSensitive = diacriticSensitive,
-                                Language = language
-                            });
-
-            return session == null
-                   ? Collection<T>(tenantPrefix).Aggregate(options).Match(filter)
-                   : Collection<T>(tenantPrefix).Aggregate(session, options).Match(filter);
+            return Context.FluentTextSearch<T>(searchType: searchType, searchTerm: searchTerm, caseSensitive: caseSensitive, diacriticSensitive: diacriticSensitive, language: language, options: options);
         }
     }
 }
diff --git a/MongoDB.Entities/DB/DB.GeoNear.cs b/MongoDB.Entities/DB/DB.GeoNear.cs
index a8e52e7c2..7f51fd763 100644
--- a/MongoDB.Entities/DB/DB.GeoNear.cs
+++ b/MongoDB.Entities/DB/DB.GeoNear.cs
@@ -21,24 +21,9 @@ public static partial class DB
         /// <param name="IncludeLocations">Specify the output field to store the point used to calculate the distance</param>
         /// <param name="IndexKey"></param>
         /// <param name="options">The options for the aggregation. This is not required.</param>
-        /// <param name="session">An optional session if using within a transaction</param>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static IAggregateFluent<T> FluentGeoNear<T>(Coordinates2D NearCoordinates, Expression<Func<T, object>> DistanceField, bool Spherical = true, double? MaxDistance = null, double? MinDistance = null, int? Limit = null, BsonDocument Query = null, double? DistanceMultiplier = null, Expression<Func<T, object>> IncludeLocations = null, string IndexKey = null, AggregateOptions options = null, IClientSessionHandle session = null, string tenantPrefix = null) where T : IEntity
+        public static IAggregateFluent<T> FluentGeoNear<T>(Coordinates2D NearCoordinates, Expression<Func<T, object>>? DistanceField, bool Spherical = true, double? MaxDistance = null, double? MinDistance = null, int? Limit = null, BsonDocument? Query = null, double? DistanceMultiplier = null, Expression<Func<T, object>>? IncludeLocations = null, string? IndexKey = null, AggregateOptions? options = null) where T : IEntity
         {
-            return new GeoNear<T>
-            {
-                near = NearCoordinates,
-                distanceField = DistanceField?.FullPath(),
-                spherical = Spherical,
-                maxDistance = MaxDistance,
-                minDistance = MinDistance,
-                query = Query,
-                distanceMultiplier = DistanceMultiplier,
-                limit = Limit,
-                includeLocs = IncludeLocations?.FullPath(),
-                key = IndexKey,
-            }
-            .ToFluent(tenantPrefix, options, session);
+            return Context.GeoNear<T>(NearCoordinates: NearCoordinates, DistanceField: DistanceField, Spherical: Spherical, MaxDistance: MaxDistance, MinDistance: MinDistance, Limit: Limit, Query: Query, DistanceMultiplier: DistanceMultiplier, IncludeLocations: IncludeLocations, IndexKey: IndexKey, options: options);
         }
     }
 }
diff --git a/MongoDB.Entities/DBContext/DBContext.File.cs b/MongoDB.Entities/DBContext/DBContext.File.cs
index 956066a22..8826cc358 100644
--- a/MongoDB.Entities/DBContext/DBContext.File.cs
+++ b/MongoDB.Entities/DBContext/DBContext.File.cs
@@ -10,15 +10,12 @@ public partial class DBContext
         /// </summary>
         /// <typeparam name="T">The file entity type</typeparam>
         /// <param name="ID">The ID of the file entity</param>
-        public DataStreamer File<T>(string ID) where T : FileEntity, new()
+        public DataStreamer<T> File<T>(string ID) where T : FileEntity, new()
         {
             if (!ObjectId.TryParse(ID, out _))
                 throw new ArgumentException("The ID passed in is not of the correct format!");
 
-            return new DataStreamer(
-                new T() { ID = ID, UploadSuccessful = true },
-                tenantPrefix);
-            return File<T>(ID);
+            return new DataStreamer<T>(new T() { ID = ID, UploadSuccessful = true }, this);
         }
     }
 }
diff --git a/MongoDB.Entities/DBContext/DBContext.Find.cs b/MongoDB.Entities/DBContext/DBContext.Find.cs
index 250ac7086..194f6cda9 100644
--- a/MongoDB.Entities/DBContext/DBContext.Find.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Find.cs
@@ -8,7 +8,7 @@ public partial class DBContext
         /// <typeparam name="T">The type of entity</typeparam>
         public Find<T> Find<T>() where T : IEntity
         {
-            return new Find<T>(this, CollectionFor<T>(), _globalFilters);
+            return new Find<T>(this, CollectionFor<T>());
         }
 
         /// <summary>
@@ -18,7 +18,7 @@ public Find<T> Find<T>() where T : IEntity
         /// <typeparam name="TProjection">The type of the end result</typeparam>
         public Find<T, TProjection> Find<T, TProjection>() where T : IEntity
         {
-            return new Find<T, TProjection>(this, CollectionFor<T>(), _globalFilters);
+            return new Find<T, TProjection>(this, CollectionFor<T>());
         }
     }
 }
diff --git a/MongoDB.Entities/DBContext/DBContext.Fluent.cs b/MongoDB.Entities/DBContext/DBContext.Fluent.cs
index fbfda43ae..649036c52 100644
--- a/MongoDB.Entities/DBContext/DBContext.Fluent.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Fluent.cs
@@ -10,18 +10,19 @@ public partial class DBContext
         /// <typeparam name="T">The type of entity</typeparam>
         /// <param name="options">The options for the aggregation. This is not required.</param>
         /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
-        public IAggregateFluent<T> Fluent<T>(AggregateOptions options = null, bool ignoreGlobalFilters = false) where T : IEntity
+        public IAggregateFluent<T> Fluent<T>(AggregateOptions? options = null, bool ignoreGlobalFilters = false) where T : IEntity
         {
             var globalFilter = Logic.MergeWithGlobalFilter(ignoreGlobalFilters, _globalFilters, Builders<T>.Filter.Empty);
 
+            var aggregate = Session is not IClientSessionHandle session
+                   ? CollectionFor<T>().Aggregate(options)
+                   : CollectionFor<T>().Aggregate(session, options);
+
             if (globalFilter != Builders<T>.Filter.Empty)
             {
-                return DB
-                    .Fluent<T>(options, Session, tenantPrefix)
-                    .Match(globalFilter);
+                aggregate = aggregate.Match(globalFilter);
             }
-
-            return DB.Fluent<T>(options, Session, tenantPrefix);
+            return aggregate;
         }
 
         /// <summary>
@@ -35,18 +36,38 @@ public IAggregateFluent<T> Fluent<T>(AggregateOptions options = null, bool ignor
         /// <param name="language">The language for the search (optional)</param>
         /// <param name="options">Options for finding documents (not required)</param>
         /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
-        public IAggregateFluent<T> FluentTextSearch<T>(Search searchType, string searchTerm, bool caseSensitive = false, bool diacriticSensitive = false, string language = null, AggregateOptions options = null, bool ignoreGlobalFilters = false) where T : IEntity
+        public IAggregateFluent<T> FluentTextSearch<T>(Search searchType, string searchTerm, bool caseSensitive = false, bool diacriticSensitive = false, string? language = null, AggregateOptions? options = null, bool ignoreGlobalFilters = false) where T : IEntity
         {
             var globalFilter = Logic.MergeWithGlobalFilter(ignoreGlobalFilters, _globalFilters, Builders<T>.Filter.Empty);
 
+            if (searchType == Search.Fuzzy)
+            {
+                searchTerm = searchTerm.ToDoubleMetaphoneHash();
+                caseSensitive = false;
+                diacriticSensitive = false;
+                language = null;
+            }
+
+            var filter = Builders<T>.Filter.Text(
+                            searchTerm,
+                            new TextSearchOptions
+                            {
+                                CaseSensitive = caseSensitive,
+                                DiacriticSensitive = diacriticSensitive,
+                                Language = language
+                            });
+
+            var aggregate = Session is not IClientSessionHandle session
+                   ? CollectionFor<T>().Aggregate(options).Match(filter)
+                   : CollectionFor<T>().Aggregate(session, options).Match(filter);
+
+
             if (globalFilter != Builders<T>.Filter.Empty)
             {
-                return DB
-                    .FluentTextSearch<T>(searchType, searchTerm, caseSensitive, diacriticSensitive, language, options, Session, tenantPrefix)
-                    .Match(globalFilter);
+                aggregate = aggregate.Match(globalFilter);
             }
 
-            return DB.FluentTextSearch<T>(searchType, searchTerm, caseSensitive, diacriticSensitive, language, options, Session, tenantPrefix);
+            return aggregate;
         }
     }
 }
diff --git a/MongoDB.Entities/DBContext/DBContext.GeoNear.cs b/MongoDB.Entities/DBContext/DBContext.GeoNear.cs
index 87bed9b59..8e9238d6f 100644
--- a/MongoDB.Entities/DBContext/DBContext.GeoNear.cs
+++ b/MongoDB.Entities/DBContext/DBContext.GeoNear.cs
@@ -23,18 +23,31 @@ public partial class DBContext
         /// <param name="options">The options for the aggregation. This is not required.</param>
         /// <typeparam name="T">The type of entity</typeparam>
         /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
-        public IAggregateFluent<T> GeoNear<T>(Coordinates2D NearCoordinates, Expression<Func<T, object>> DistanceField, bool Spherical = true, int? MaxDistance = null, int? MinDistance = null, int? Limit = null, BsonDocument Query = null, int? DistanceMultiplier = null, Expression<Func<T, object>> IncludeLocations = null, string IndexKey = null, AggregateOptions options = null, bool ignoreGlobalFilters = false) where T : IEntity
+        public IAggregateFluent<T> GeoNear<T>(Coordinates2D NearCoordinates, Expression<Func<T, object>>? DistanceField, bool Spherical = true, double? MaxDistance = null, double? MinDistance = null, int? Limit = null, BsonDocument? Query = null, double? DistanceMultiplier = null, Expression<Func<T, object>>? IncludeLocations = null, string? IndexKey = null, AggregateOptions? options = null, bool ignoreGlobalFilters = false) where T : IEntity
         {
             var globalFilter = Logic.MergeWithGlobalFilter(ignoreGlobalFilters, _globalFilters, Builders<T>.Filter.Empty);
 
+            var fluent = new GeoNear<T>
+            {
+                near = NearCoordinates,
+                distanceField = DistanceField?.FullPath(),
+                spherical = Spherical,
+                maxDistance = MaxDistance,
+                minDistance = MinDistance,
+                query = Query,
+                distanceMultiplier = DistanceMultiplier,
+                limit = Limit,
+                includeLocs = IncludeLocations?.FullPath(),
+                key = IndexKey,
+            }
+            .ToFluent(this, options);
+
             if (globalFilter != Builders<T>.Filter.Empty)
             {
-                return DB
-                    .FluentGeoNear(NearCoordinates, DistanceField, Spherical, MaxDistance, MinDistance, Limit, Query, DistanceMultiplier, IncludeLocations, IndexKey, options, Session, tenantPrefix)
-                    .Match(globalFilter);
+                fluent = fluent.Match(globalFilter);
             }
 
-            return DB.FluentGeoNear(NearCoordinates, DistanceField, Spherical, MaxDistance, MinDistance, Limit, Query, DistanceMultiplier, IncludeLocations, IndexKey, options, Session, tenantPrefix);
+            return fluent;
         }
     }
 }
diff --git a/MongoDB.Entities/DBContext/DBContext.Index.cs b/MongoDB.Entities/DBContext/DBContext.Index.cs
index c7b1eff3b..9898d7cdd 100644
--- a/MongoDB.Entities/DBContext/DBContext.Index.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Index.cs
@@ -9,7 +9,7 @@ public partial class DBContext
         /// <typeparam name="T">Any class that implements IEntity</typeparam>
         public Index<T> Index<T>() where T : IEntity
         {
-            return new Index<T>(tenantPrefix);
+            return new Index<T>(this, CollectionFor<T>());
         }
     }
 }
diff --git a/MongoDB.Entities/DBContext/DBContext.Insert.cs b/MongoDB.Entities/DBContext/DBContext.Insert.cs
index b40985b8f..da90c4884 100644
--- a/MongoDB.Entities/DBContext/DBContext.Insert.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Insert.cs
@@ -17,9 +17,8 @@ public partial class DBContext
         public Task InsertAsync<T>(T entity, CancellationToken cancellation = default) where T : IEntity
         {
             SetModifiedBySingle(entity);
-            entity.SetTenantPrefixOnFileEntity(tenantPrefix);
             OnBeforeSave<T>()?.Invoke(entity);
-            return DB.InsertAsync(entity, Session, cancellation, tenantPrefix);
+            return DB.InsertAsync(entity, Session, cancellation);
         }
 
         /// <summary>
@@ -32,9 +31,8 @@ public Task InsertAsync<T>(T entity, CancellationToken cancellation = default) w
         public Task<BulkWriteResult<T>> InsertAsync<T>(IEnumerable<T> entities, CancellationToken cancellation = default) where T : IEntity
         {
             SetModifiedByMultiple(entities);
-            entities.SetTenantDbOnFileEntities(tenantPrefix);
             foreach (var ent in entities) OnBeforeSave<T>()?.Invoke(ent);
-            return DB.InsertAsync(entities, Session, cancellation, tenantPrefix);
+            return DB.InsertAsync(entities, Session, cancellation);
         }
     }
 }
diff --git a/MongoDB.Entities/DBContext/DBContext.Pipeline.cs b/MongoDB.Entities/DBContext/DBContext.Pipeline.cs
index 6ea5e01f7..927d9eeab 100644
--- a/MongoDB.Entities/DBContext/DBContext.Pipeline.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Pipeline.cs
@@ -21,7 +21,7 @@ public partial class DBContext
         /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
         public Task<IAsyncCursor<TResult>> PipelineCursorAsync<T, TResult>(Template<T, TResult> template, AggregateOptions options = null, CancellationToken cancellation = default, bool ignoreGlobalFilters = false) where T : IEntity
         {
-            return DB.PipelineCursorAsync(MergeGlobalFilter(template, ignoreGlobalFilters), options, Session, cancellation, tenantPrefix);
+            return DB.PipelineCursorAsync(MergeGlobalFilter(template, ignoreGlobalFilters), options, Session, cancellation);
         }
 
         /// <summary>
@@ -36,7 +36,7 @@ public Task<IAsyncCursor<TResult>> PipelineCursorAsync<T, TResult>(Template<T, T
         /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
         public Task<List<TResult>> PipelineAsync<T, TResult>(Template<T, TResult> template, AggregateOptions options = null, CancellationToken cancellation = default, bool ignoreGlobalFilters = false) where T : IEntity
         {
-            return DB.PipelineAsync(MergeGlobalFilter(template, ignoreGlobalFilters), options, Session, cancellation, tenantPrefix);
+            return DB.PipelineAsync(MergeGlobalFilter(template, ignoreGlobalFilters), options, Session, cancellation);
         }
 
         /// <summary>
@@ -51,7 +51,7 @@ public Task<List<TResult>> PipelineAsync<T, TResult>(Template<T, TResult> templa
         /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
         public Task<TResult> PipelineSingleAsync<T, TResult>(Template<T, TResult> template, AggregateOptions options = null, CancellationToken cancellation = default, bool ignoreGlobalFilters = false) where T : IEntity
         {
-            return DB.PipelineSingleAsync(MergeGlobalFilter(template, ignoreGlobalFilters), options, Session, cancellation, tenantPrefix);
+            return DB.PipelineSingleAsync(MergeGlobalFilter(template, ignoreGlobalFilters), options, Session, cancellation);
         }
 
         /// <summary>
@@ -66,7 +66,7 @@ public Task<TResult> PipelineSingleAsync<T, TResult>(Template<T, TResult> templa
         /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
         public Task<TResult> PipelineFirstAsync<T, TResult>(Template<T, TResult> template, AggregateOptions options = null, CancellationToken cancellation = default, bool ignoreGlobalFilters = false) where T : IEntity
         {
-            return DB.PipelineFirstAsync(MergeGlobalFilter(template, ignoreGlobalFilters), options, Session, cancellation, tenantPrefix);
+            return DB.PipelineFirstAsync(MergeGlobalFilter(template, ignoreGlobalFilters), options, Session, cancellation);
         }
 
         private Template<T, TResult> MergeGlobalFilter<T, TResult>(Template<T, TResult> template, bool ignoreGlobalFilters) where T : IEntity
diff --git a/MongoDB.Entities/DBContext/DBContext.Save.cs b/MongoDB.Entities/DBContext/DBContext.Save.cs
index b0f8b8a0a..c79ebd972 100644
--- a/MongoDB.Entities/DBContext/DBContext.Save.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Save.cs
@@ -21,9 +21,8 @@ public partial class DBContext
         public Task SaveAsync<T>(T entity, CancellationToken cancellation = default) where T : IEntity
         {
             SetModifiedBySingle(entity);
-            entity.SetTenantPrefixOnFileEntity(tenantPrefix);
             OnBeforeSave<T>()?.Invoke(entity);
-            return DB.SaveAsync(entity, Session, cancellation, tenantPrefix);
+            return DB.SaveAsync(entity, Session, cancellation);
         }
 
         /// <summary>
@@ -36,9 +35,8 @@ public Task SaveAsync<T>(T entity, CancellationToken cancellation = default) whe
         public Task<BulkWriteResult<T>> SaveAsync<T>(IEnumerable<T> entities, CancellationToken cancellation = default) where T : IEntity
         {
             SetModifiedByMultiple(entities);
-            entities.SetTenantDbOnFileEntities(tenantPrefix);
             foreach (var ent in entities) OnBeforeSave<T>()?.Invoke(ent);
-            return DB.SaveAsync(entities, Session, cancellation, tenantPrefix);
+            return DB.SaveAsync(entities, Session, cancellation);
         }
 
         /// <summary>
@@ -54,9 +52,8 @@ public Task<BulkWriteResult<T>> SaveAsync<T>(IEnumerable<T> entities, Cancellati
         public Task<UpdateResult> SaveOnlyAsync<T>(T entity, Expression<Func<T, object>> members, CancellationToken cancellation = default) where T : IEntity
         {
             SetModifiedBySingle(entity);
-            entity.SetTenantPrefixOnFileEntity(tenantPrefix);
             OnBeforeSave<T>()?.Invoke(entity);
-            return DB.SaveOnlyAsync(entity, members, Session, cancellation, tenantPrefix);
+            return DB.SaveOnlyAsync(entity, members, Session, cancellation);
         }
 
         /// <summary>
@@ -72,9 +69,8 @@ public Task<UpdateResult> SaveOnlyAsync<T>(T entity, Expression<Func<T, object>>
         public Task<BulkWriteResult<T>> SaveOnlyAsync<T>(IEnumerable<T> entities, Expression<Func<T, object>> members, CancellationToken cancellation = default) where T : IEntity
         {
             SetModifiedByMultiple(entities);
-            entities.SetTenantDbOnFileEntities(tenantPrefix);
             foreach (var ent in entities) OnBeforeSave<T>()?.Invoke(ent);
-            return DB.SaveOnlyAsync(entities, members, Session, cancellation, tenantPrefix);
+            return DB.SaveOnlyAsync(entities, members, Session, cancellation);
         }
 
         /// <summary>
@@ -90,9 +86,8 @@ public Task<BulkWriteResult<T>> SaveOnlyAsync<T>(IEnumerable<T> entities, Expres
         public Task<UpdateResult> SaveExceptAsync<T>(T entity, Expression<Func<T, object>> members, CancellationToken cancellation = default) where T : IEntity
         {
             SetModifiedBySingle(entity);
-            entity.SetTenantPrefixOnFileEntity(tenantPrefix);
             OnBeforeSave<T>()?.Invoke(entity);
-            return DB.SaveExceptAsync(entity, members, Session, cancellation, tenantPrefix);
+            return DB.SaveExceptAsync(entity, members, Session, cancellation);
         }
 
         /// <summary>
@@ -108,9 +103,8 @@ public Task<UpdateResult> SaveExceptAsync<T>(T entity, Expression<Func<T, object
         public Task<BulkWriteResult<T>> SaveExceptAsync<T>(IEnumerable<T> entities, Expression<Func<T, object>> members, CancellationToken cancellation = default) where T : IEntity
         {
             SetModifiedByMultiple(entities);
-            entities.SetTenantDbOnFileEntities(tenantPrefix);
             foreach (var ent in entities) OnBeforeSave<T>()?.Invoke(ent);
-            return DB.SaveExceptAsync(entities, members, Session, cancellation, tenantPrefix);
+            return DB.SaveExceptAsync(entities, members, Session, cancellation);
         }
 
         /// <summary>
@@ -123,32 +117,33 @@ public Task<BulkWriteResult<T>> SaveExceptAsync<T>(IEnumerable<T> entities, Expr
         public Task<UpdateResult> SavePreservingAsync<T>(T entity, CancellationToken cancellation = default) where T : IEntity
         {
             SetModifiedBySingle(entity);
-            entity.SetTenantPrefixOnFileEntity(tenantPrefix);
             OnBeforeSave<T>()?.Invoke(entity);
-            return DB.SavePreservingAsync(entity, Session, cancellation, tenantPrefix);
+            return DB.SavePreservingAsync(entity, Session, cancellation);
         }
 
         private void SetModifiedBySingle<T>(T entity) where T : IEntity
         {
             ThrowIfModifiedByIsEmpty<T>();
-            Cache<T>.ModifiedByProp?.SetValue(
+            var cache = Cache<T>();
+            cache.ModifiedByProp?.SetValue(
                 entity,
-                BsonSerializer.Deserialize(ModifiedBy.ToBson(), Cache<T>.ModifiedByProp.PropertyType));
+                BsonSerializer.Deserialize(ModifiedBy.ToBson(), cache.ModifiedByProp.PropertyType));
             //note: we can't use an IModifiedBy interface because the above line needs a concrete type
             //      to be able to correctly deserialize a user supplied derived/sub class of ModifiedOn.
         }
 
         private void SetModifiedByMultiple<T>(IEnumerable<T> entities) where T : IEntity
         {
-            if (Cache<T>.ModifiedByProp is null)
+            var cache = Cache<T>();
+            if (Cache<T>().ModifiedByProp is null)
                 return;
 
             ThrowIfModifiedByIsEmpty<T>();
 
-            var val = BsonSerializer.Deserialize(ModifiedBy.ToBson(), Cache<T>.ModifiedByProp.PropertyType);
+            var val = BsonSerializer.Deserialize(ModifiedBy.ToBson(), cache.ModifiedByProp.PropertyType);
 
             foreach (var e in entities)
-                Cache<T>.ModifiedByProp.SetValue(e, val);
+                cache.ModifiedByProp.SetValue(e, val);
         }
     }
 }
diff --git a/MongoDB.Entities/DBContext/DBContext.cs b/MongoDB.Entities/DBContext/DBContext.cs
index f5b2e08c2..4f06b90d9 100644
--- a/MongoDB.Entities/DBContext/DBContext.cs
+++ b/MongoDB.Entities/DBContext/DBContext.cs
@@ -290,10 +290,13 @@ internal Cache<T> Cache<T>() where T : IEntity
             }
             return (Cache<T>)c;
         }
-
-        public IMongoCollection<T> CollectionFor<T>() where T : IEntity
+        public virtual string CollectionNameFor<T>() where T : IEntity
+        {
+            return Cache<T>().CollectionName;
+        }
+        public virtual IMongoCollection<T> CollectionFor<T>() where T : IEntity
         {
-            return Database.GetCollection<T>(Cache<T>().CollectionName);
+            return Database.GetCollection<T>(CollectionNameFor<T>());
         }
     }
 }

From 0141761c5a5844917ad3d683040fb2600a4ea3d4 Mon Sep 17 00:00:00 2001
From: Ahmed Fwela <ahmednfwela@bdaya-dev.com>
Date: Wed, 10 Nov 2021 13:19:52 +0200
Subject: [PATCH 15/26] DBContext is done

---
 MongoDB.Entities/Builders/Find.cs             |   9 +-
 MongoDB.Entities/Builders/Replace.cs          |   7 +-
 MongoDB.Entities/Builders/Update.cs           |  15 +-
 MongoDB.Entities/Builders/UpdateAndGet.cs     |   4 +-
 .../Core/{Cache.cs => EntityCache.cs}         | 239 ++++----
 MongoDB.Entities/Core/FileEntity.cs           |  12 +-
 MongoDB.Entities/Core/GeoNear.cs              |   8 +-
 MongoDB.Entities/Core/Logic.cs                |   6 +-
 MongoDB.Entities/Core/Prop.cs                 |   2 +-
 MongoDB.Entities/Core/SequenceCounter.cs      |   2 +-
 MongoDB.Entities/Core/Watcher.cs              | 174 +++---
 MongoDB.Entities/DB/DB.Collection.cs          |  11 +-
 MongoDB.Entities/DB/DB.Count.cs               |   3 -
 MongoDB.Entities/DB/DB.Distinct.cs            |   7 +-
 MongoDB.Entities/DB/DB.File.cs                |   2 +-
 MongoDB.Entities/DB/DB.Find.cs                |  12 +-
 MongoDB.Entities/DB/DB.Index.cs               |   9 +-
 MongoDB.Entities/DB/DB.Insert.cs              |  23 +-
 MongoDB.Entities/DB/DB.Pipeline.cs            |  45 +-
 MongoDB.Entities/DB/DB.Save.cs                | 154 +-----
 MongoDB.Entities/DB/DB.Sequence.cs            |  15 +-
 MongoDB.Entities/DB/DB.Watcher.cs             |  12 +-
 MongoDB.Entities/DB/DB.cs                     | 140 ++---
 .../DBCollection.IMongoCollection.cs          | 487 +++++++++++++++++
 MongoDB.Entities/DBCollection/DBCollection.cs |  24 +
 .../DBContext/DBContext.Collection.cs         |  82 +--
 MongoDB.Entities/DBContext/DBContext.Count.cs | 131 ++---
 .../DBContext/DBContext.Delete.cs             | 272 ++++-----
 .../DBContext/DBContext.Distinct.cs           |  23 +-
 MongoDB.Entities/DBContext/DBContext.File.cs  |  28 +-
 MongoDB.Entities/DBContext/DBContext.Find.cs  |  39 +-
 .../DBContext/DBContext.Fluent.cs             |  16 +-
 .../DBContext/DBContext.GeoNear.cs            |   6 +-
 .../DBContext/DBContext.IMongoDatabase.cs     |  10 +-
 MongoDB.Entities/DBContext/DBContext.Index.cs |   8 +-
 .../DBContext/DBContext.Insert.cs             |  72 ++-
 .../DBContext/DBContext.PagedSearch.cs        |  12 +-
 .../DBContext/DBContext.Pipeline.cs           |  52 +-
 .../DBContext/DBContext.Queryable.cs          |  10 +-
 .../DBContext/DBContext.Replace.cs            |   8 +-
 MongoDB.Entities/DBContext/DBContext.Save.cs  | 137 ++++-
 .../DBContext/DBContext.Sequence.cs           |  13 +-
 .../DBContext/DBContext.Transaction.cs        |  38 +-
 .../DBContext/DBContext.Update.cs             |  25 +-
 .../DBContext/DBContext.Watcher.cs            |  17 +-
 MongoDB.Entities/DBContext/DBContext.cs       | 514 ++++++++++--------
 MongoDB.Entities/DBContext/TenantContext.cs   |  69 ---
 .../MongoContext/MongoContext.IMongoClient.cs |   5 +-
 MongoDB.Entities/MongoContext/MongoContext.cs |  13 +-
 MongoDB.Entities/MongoDB.Entities.csproj      |   2 +-
 MongoDB.Entities/Relationships/JoinRecord.cs  |   4 +-
 MongoDB.Entities/Relationships/Many.Remove.cs |   2 +-
 52 files changed, 1761 insertions(+), 1269 deletions(-)
 rename MongoDB.Entities/Core/{Cache.cs => EntityCache.cs} (57%)
 create mode 100644 MongoDB.Entities/DBCollection/DBCollection.IMongoCollection.cs
 create mode 100644 MongoDB.Entities/DBCollection/DBCollection.cs
 delete mode 100644 MongoDB.Entities/DBContext/TenantContext.cs

diff --git a/MongoDB.Entities/Builders/Find.cs b/MongoDB.Entities/Builders/Find.cs
index 77a45df25..cd51a3335 100644
--- a/MongoDB.Entities/Builders/Find.cs
+++ b/MongoDB.Entities/Builders/Find.cs
@@ -10,7 +10,7 @@
 #nullable enable
 namespace MongoDB.Entities
 {
-    public class FindBase<T, TProjection, TSelf> : SortFilterQueryBase<T, TSelf> where T : IEntity where TSelf : FindBase<T, TProjection, TSelf>
+    public abstract class FindBase<T, TProjection, TSelf> : SortFilterQueryBase<T, TSelf> where T : IEntity where TSelf : FindBase<T, TProjection, TSelf>
     {
         internal FindOptions<T, TProjection> _options = new();
 
@@ -22,7 +22,7 @@ internal FindBase(Dictionary<Type, (object filterDef, bool prepend)> globalFilte
         {
             _globalFilters = globalFilters;
         }
-
+        public abstract DBContext Context { get; }
         private TSelf This => (TSelf)this;
 
         /// <summary>
@@ -73,7 +73,7 @@ public TSelf IncludeRequiredProps()
             if (typeof(T) != typeof(TProjection))
                 throw new InvalidOperationException("IncludeRequiredProps() cannot be used when projecting to a different type.");
 
-            _options.Projection = Cache<T>.Instance.CombineWithRequiredProps(_options.Projection);
+            _options.Projection = Context.Cache<T>().CombineWithRequiredProps(_options.Projection);
             return This;
         }
 
@@ -174,6 +174,7 @@ internal Find(DBContext context, IMongoCollection<T> collection, FindBase<T, T,
     /// <typeparam name="TProjection">The type you'd like to project the results to.</typeparam>
     public class Find<T, TProjection> : FindBase<T, TProjection, Find<T, TProjection>>, ICollectionRelated<T> where T : IEntity
     {
+
         /// <summary>
         /// copy constructor
         /// </summary>
@@ -191,7 +192,7 @@ internal Find(DBContext context, IMongoCollection<T> collection) : base(context.
             Collection = collection;
         }
 
-        public DBContext Context { get; private set; }
+        public override DBContext Context { get; }
         public IMongoCollection<T> Collection { get; private set; }
 
 
diff --git a/MongoDB.Entities/Builders/Replace.cs b/MongoDB.Entities/Builders/Replace.cs
index 29004d5c7..1f02ea2d5 100644
--- a/MongoDB.Entities/Builders/Replace.cs
+++ b/MongoDB.Entities/Builders/Replace.cs
@@ -19,7 +19,7 @@ public class Replace<T> : FilterQueryBase<T, Replace<T>>, ICollectionRelated<T>
         private ReplaceOptions _options = new();
         private readonly List<ReplaceOneModel<T>> _models = new();
         private readonly ModifiedBy? _modifiedBy;
-        private readonly Action<T> _onSaveAction;
+        private readonly Action<T>? _onSaveAction;
         private T? _entity;
 
         public DBContext Context { get; }
@@ -28,12 +28,11 @@ public class Replace<T> : FilterQueryBase<T, Replace<T>>, ICollectionRelated<T>
         internal Replace(
             DBContext context,
             IMongoCollection<T> collection,
-            ModifiedBy modifiedBy,
-            Action<T> onSaveAction) : base(context.GlobalFilters)
+            Action<T>? onSaveAction) : base(context.GlobalFilters)
         {
             Context = context;
             Collection = collection;
-            _modifiedBy = modifiedBy;
+            _modifiedBy = context.ModifiedBy;
             _onSaveAction = onSaveAction;
         }
 
diff --git a/MongoDB.Entities/Builders/Update.cs b/MongoDB.Entities/Builders/Update.cs
index 35c43fdfd..0f9426fbb 100644
--- a/MongoDB.Entities/Builders/Update.cs
+++ b/MongoDB.Entities/Builders/Update.cs
@@ -14,7 +14,9 @@ public abstract class UpdateBase<T, TSelf> : FilterQueryBase<T, TSelf> where T :
         protected readonly List<UpdateDefinition<T>> defs;
         protected readonly Action<TSelf>? onUpdateAction;
 
-        internal abstract Cache<T> Cache();
+        public abstract DBContext Context { get; }
+        private EntityCache<T>? _cache;
+        internal EntityCache<T> Cache() => _cache ??= Context.Cache<T>();
 
         internal UpdateBase(UpdateBase<T, TSelf> other) : base(other)
         {
@@ -116,7 +118,7 @@ public TSelf ModifyWith(T entity)
         {
 
             if (Cache().HasModifiedOn) ((IModifiedOn)entity).ModifiedOn = DateTime.UtcNow;
-            defs.AddRange(Logic.BuildUpdateDefs(entity));
+            defs.AddRange(Logic.BuildUpdateDefs(entity, Context));
             return This;
         }
 
@@ -168,17 +170,10 @@ internal Update(DBContext context, IMongoCollection<T> collection, Action<Update
             Collection = collection;
         }
 
-        public DBContext Context { get; }
+        public override DBContext Context { get; }
         public IMongoCollection<T> Collection { get; }
 
 
-        private Cache<T>? _cache;
-        internal override Cache<T> Cache() => _cache ??= Context.Cache<T>();
-
-
-
-
-
         /// <summary>
         /// Specify an update pipeline with multiple stages using a Template to modify the Entities.
         /// <para>NOTE: pipeline updates and regular updates cannot be used together.</para>
diff --git a/MongoDB.Entities/Builders/UpdateAndGet.cs b/MongoDB.Entities/Builders/UpdateAndGet.cs
index 5f32d46d2..26ec002e6 100644
--- a/MongoDB.Entities/Builders/UpdateAndGet.cs
+++ b/MongoDB.Entities/Builders/UpdateAndGet.cs
@@ -51,8 +51,8 @@ internal UpdateAndGet(DBContext context, IMongoCollection<T> collection, Action<
             Collection = collection;
         }
 
-        private Cache<T>? _cache;
-        internal override Cache<T> Cache() => _cache ??= Context.Cache<T>();
+        private EntityCache<T>? _cache;
+        internal override EntityCache<T> Cache() => _cache ??= Context.Cache<T>();
 
         /// <summary>
         /// Specify an update pipeline with multiple stages using a Template to modify the Entities.
diff --git a/MongoDB.Entities/Core/Cache.cs b/MongoDB.Entities/Core/EntityCache.cs
similarity index 57%
rename from MongoDB.Entities/Core/Cache.cs
rename to MongoDB.Entities/Core/EntityCache.cs
index 704b71802..0fc9c30a3 100644
--- a/MongoDB.Entities/Core/Cache.cs
+++ b/MongoDB.Entities/Core/EntityCache.cs
@@ -1,169 +1,122 @@
-using MongoDB.Bson.Serialization;
-using MongoDB.Bson.Serialization.Attributes;
+using MongoDB.Bson.Serialization;
+using MongoDB.Bson.Serialization.Attributes;
 using MongoDB.Driver;
-using MongoDB.Driver.Linq;
+using MongoDB.Driver.Linq;
 using System;
 using System.Collections.Concurrent;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
 #nullable enable
 namespace MongoDB.Entities
 {
-    internal abstract class Cache
-    {
-        //key: entity type
-        //val: collection name
-        protected readonly ConcurrentDictionary<Type, string> typeToCollectionNameMap = new();
-
-        //key: entity type
-        //val: database name without tenant prefix (will be null if not specifically set using DB.DatabaseFor<T>() method)
-        protected readonly ConcurrentDictionary<Type, string> typeToDbNameWithoutTenantPrefixMap = new();
-
-        internal string CollectionNameFor(Type entityType)
-            => typeToCollectionNameMap[entityType];
-
-        internal void MapTypeToDbNameWithoutTenantPrefix<T>(string dbNameWithoutTenantPrefix) where T : IEntity
-            => typeToDbNameWithoutTenantPrefixMap[typeof(T)] = dbNameWithoutTenantPrefix;
-
-        internal string GetFullDbName(Type entityType, string tenantPrefix)
-        {
-            string fullDbName = null;
-
-            string dbNameWithoutTenantPrefix = typeToDbNameWithoutTenantPrefixMap[entityType];
-
-            if (!string.IsNullOrEmpty(dbNameWithoutTenantPrefix))
-            {
-                if (!string.IsNullOrEmpty(tenantPrefix))
-                    fullDbName = $"{tenantPrefix}~{dbNameWithoutTenantPrefix}";
-                else
-                    fullDbName = dbNameWithoutTenantPrefix;
-            }
-
-            return fullDbName;
-        }
+    internal abstract class Cache
+    {
+        protected PropertyInfo[] _updatableProps = null!;
+
+        public bool HasCreatedOn { get; protected set; }
+        public bool HasModifiedOn { get; protected set; }
+        public string ModifiedOnPropName { get; } = nameof(IModifiedOn.ModifiedOn);
+        public PropertyInfo? ModifiedByProp { get; protected set; }
+        public bool HasIgnoreIfDefaultProps { get; protected set; }
+        public string CollectionName { get; protected set; } = null!;
+        public bool IsFileEntity { get; protected set; }
     }
 
-    internal class Cache<T> : Cache where T : IEntity
+    internal class EntityCache<T> : Cache where T : IEntity
     {
-        private static Cache<T>? _instance;
-        public static Cache<T> Instance => _instance ??= new();
-
+        
+
         public ConcurrentDictionary<string, Watcher<T>> Watchers { get; } = new();
-        public bool HasCreatedOn { get; }
-        public bool HasModifiedOn { get; }
-        public string ModifiedOnPropName { get; }
-        public PropertyInfo ModifiedByProp { get; }
-        public bool HasIgnoreIfDefaultProps { get; }
-        public string CollectionName { get; }
-        public bool IsFileEntity { get; }
-
-        //key: TenantPrefix:CollectionName
-        //val: IMongoCollection<T>
-        private readonly ConcurrentDictionary<string, IMongoCollection<T>> _cache = new();
-        private readonly PropertyInfo[] _updatableProps;
+
         private ProjectionDefinition<T>? _requiredPropsProjection;
 
-        public Cache()
+        public EntityCache()
         {
-            var type = typeof(T);
-            var interfaces = type.GetInterfaces();
-
-            var collAttrb = type.GetCustomAttribute<CollectionAttribute>(false);
-
-            CollectionName = collAttrb != null ? collAttrb.Name : type.Name;
-
-            if (string.IsNullOrWhiteSpace(CollectionName) || CollectionName.Contains("~"))
-                throw new ArgumentException($"{CollectionName} is an illegal name for a collection!");
-
-            typeToCollectionNameMap[type] = CollectionName;
-
-            if (!typeToDbNameWithoutTenantPrefixMap.ContainsKey(type))
-                typeToDbNameWithoutTenantPrefixMap[type] = null;
-
+            var type = typeof(T);
+            var interfaces = type.GetInterfaces();
+
+            var collAttrb = type.GetCustomAttribute<CollectionAttribute>(false);
+
+            CollectionName = collAttrb != null ? collAttrb.Name : type.Name;
+
+            if (string.IsNullOrWhiteSpace(CollectionName) || CollectionName.Contains("~"))
+                throw new ArgumentException($"{CollectionName} is an illegal name for a collection!");
+
+
             HasCreatedOn = interfaces.Any(i => i == typeof(ICreatedOn));
             HasModifiedOn = interfaces.Any(i => i == typeof(IModifiedOn));
-            ModifiedOnPropName = nameof(IModifiedOn.ModifiedOn);
-            IsFileEntity = type.BaseType == typeof(FileEntity);
+            IsFileEntity = typeof(FileEntity).IsAssignableFrom(type.BaseType);
 
-            _updatableProps = type.GetProperties()
-                .Where(p =>
-                       p.PropertyType.Name != ManyBase.PropTypeName &&
+            _updatableProps = type.GetProperties()
+                .Where(p =>
+                       p.PropertyType.Name != ManyBase.PropTypeName &&
                       !p.IsDefined(typeof(BsonIdAttribute), false) &&
                       !p.IsDefined(typeof(BsonIgnoreAttribute), false))
-                .ToArray();
-
-            HasIgnoreIfDefaultProps = _updatableProps.Any(p =>
-                    p.IsDefined(typeof(BsonIgnoreIfDefaultAttribute), false) ||
-                    p.IsDefined(typeof(BsonIgnoreIfNullAttribute), false));
-
-            try
-            {
-                ModifiedByProp = _updatableProps.SingleOrDefault(p =>
-                                p.PropertyType == typeof(ModifiedBy) ||
-                                p.PropertyType.IsSubclassOf(typeof(ModifiedBy)));
-            }
-            catch (InvalidOperationException)
-            {
-                throw new InvalidOperationException("Multiple [ModifiedBy] properties are not allowed on entities!");
+                .ToArray();
+
+            HasIgnoreIfDefaultProps = _updatableProps.Any(p =>
+                    p.IsDefined(typeof(BsonIgnoreIfDefaultAttribute), false) ||
+                    p.IsDefined(typeof(BsonIgnoreIfNullAttribute), false));
+
+            try
+            {
+                ModifiedByProp = _updatableProps.SingleOrDefault(p => typeof(ModifiedBy).IsAssignableFrom(p.PropertyType));
+            }
+            catch (InvalidOperationException)
+            {
+                throw new InvalidOperationException("Multiple [ModifiedBy] properties are not allowed on entities!");
             }
-        }
-
-        public IMongoCollection<T> Collection(string tenantPrefix)
-        {
-            return _cache.GetOrAdd(
-                key: $"{tenantPrefix}:{CollectionName}",
-                valueFactory: _ => DB.Database(GetFullDbName(typeof(T), tenantPrefix)).GetCollection<T>(CollectionName));
-        }
-
-        public IEnumerable<PropertyInfo> UpdatableProps(T entity)
-        {
-            if (HasIgnoreIfDefaultProps)
-            {
-                return _updatableProps.Where(p =>
-                    !(p.IsDefined(typeof(BsonIgnoreIfDefaultAttribute), false) && p.GetValue(entity) == default) &&
-                    !(p.IsDefined(typeof(BsonIgnoreIfNullAttribute), false) && p.GetValue(entity) == null));
-            }
-            return _updatableProps;
         }
 
-        public ProjectionDefinition<T, TProjection> CombineWithRequiredProps<TProjection>(ProjectionDefinition<T, TProjection> userProjection)
-        {
-            if (userProjection == null)
-                throw new InvalidOperationException("Please use .Project() method before .IncludeRequiredProps()");
-
-            if (_requiredPropsProjection is null)
-            {
-                _requiredPropsProjection = "{_id:1}";
-
-                var props = typeof(T)
-                    .GetProperties()
-                    .Where(p => p.IsDefined(typeof(BsonRequiredAttribute), false));
-
-                if (!props.Any())
-                    throw new InvalidOperationException("Unable to find any entity properties marked with [BsonRequired] attribute!");
-
-                FieldAttribute attr;
-                foreach (var p in props)
-                {
-                    attr = p.GetCustomAttribute<FieldAttribute>();
-
-                    if (attr is null)
-                        _requiredPropsProjection = _requiredPropsProjection.Include(p.Name);
-                    else
-                        _requiredPropsProjection = _requiredPropsProjection.Include(attr.ElementName);
-                }
-            }
-
-            ProjectionDefinition<T> userProj = userProjection.Render(
-                BsonSerializer.LookupSerializer<T>(),
-                BsonSerializer.SerializerRegistry).Document;
-
-            return Builders<T>.Projection.Combine(new[]
-            {
-                _requiredPropsProjection,
-                userProj
-            });
+        public IEnumerable<PropertyInfo> UpdatableProps(T entity)
+        {
+            if (HasIgnoreIfDefaultProps)
+            {
+                return _updatableProps.Where(p =>
+                    !(p.IsDefined(typeof(BsonIgnoreIfDefaultAttribute), false) && p.GetValue(entity) == default) &&
+                    !(p.IsDefined(typeof(BsonIgnoreIfNullAttribute), false) && p.GetValue(entity) == null));
+            }
+            return _updatableProps;
+        }
+
+        public ProjectionDefinition<T, TProjection> CombineWithRequiredProps<TProjection>(ProjectionDefinition<T, TProjection> userProjection)
+        {
+            if (userProjection == null)
+                throw new InvalidOperationException("Please use .Project() method before .IncludeRequiredProps()");
+
+            if (_requiredPropsProjection is null)
+            {
+                _requiredPropsProjection = "{_id:1}";
+
+                var props = typeof(T)
+                    .GetProperties()
+                    .Where(p => p.IsDefined(typeof(BsonRequiredAttribute), false));
+
+                if (!props.Any())
+                    throw new InvalidOperationException("Unable to find any entity properties marked with [BsonRequired] attribute!");
+
+                FieldAttribute attr;
+                foreach (var p in props)
+                {
+                    attr = p.GetCustomAttribute<FieldAttribute>();
+
+                    if (attr is null)
+                        _requiredPropsProjection = _requiredPropsProjection.Include(p.Name);
+                    else
+                        _requiredPropsProjection = _requiredPropsProjection.Include(attr.ElementName);
+                }
+            }
+
+            ProjectionDefinition<T> userProj = userProjection.Render(
+                BsonSerializer.LookupSerializer<T>(),
+                BsonSerializer.SerializerRegistry).Document;
+
+            return Builders<T>.Projection.Combine(new[]
+            {
+                _requiredPropsProjection,
+                userProj
+            });
         }
     }
 }
\ No newline at end of file
diff --git a/MongoDB.Entities/Core/FileEntity.cs b/MongoDB.Entities/Core/FileEntity.cs
index 6d6add2de..97a2349c2 100644
--- a/MongoDB.Entities/Core/FileEntity.cs
+++ b/MongoDB.Entities/Core/FileEntity.cs
@@ -66,6 +66,7 @@ public class DataStreamer<T> where T : FileEntity
 
         private readonly T _parent;
         private readonly DBContext _db;
+        private readonly IMongoCollection<T> _collection;
         private readonly IMongoCollection<FileChunk> _chunkCollection;
         private FileChunk? _doc;
         private int _chunkSize, _readCount;
@@ -73,12 +74,12 @@ public class DataStreamer<T> where T : FileEntity
         private List<byte>? _dataChunk;
         private MD5? _md5;
 
-        internal DataStreamer(T parent, DBContext db)
+        internal DataStreamer(T parent, DBContext db, IMongoCollection<T> collection)
         {
             _parent = parent;
             _db = db;
-            _chunkCollection = db.CollectionFor<FileChunk>();
-
+            _chunkCollection = db.Collection<FileChunk>();
+            _collection = collection;
             if (_indexedDBs.Add(db.DatabaseNamespace.DatabaseName))
             {
                 _ = _chunkCollection.Indexes.CreateOneAsync(
@@ -266,7 +267,6 @@ private Task FlushToDBAsync(bool isLastChunk = false, CancellationToken cancella
 
         private Task UpdateMetaDataAsync()
         {
-            var collection = _db.CollectionFor<T>();
             var filter = Builders<T>.Filter.Eq(e => e.ID, _parent.ID);
             var update = Builders<T>.Update
                             .Set(e => e.FileSize, _parent.FileSize)
@@ -274,8 +274,8 @@ private Task UpdateMetaDataAsync()
                             .Set(e => e.UploadSuccessful, _parent.UploadSuccessful);
 
             return _db.Session is not IClientSessionHandle session
-                   ? collection.UpdateOneAsync(filter, update)
-                   : collection.UpdateOneAsync(session, filter, update);
+                   ? _collection.UpdateOneAsync(filter, update)
+                   : _collection.UpdateOneAsync(session, filter, update);
         }
     }
 }
diff --git a/MongoDB.Entities/Core/GeoNear.cs b/MongoDB.Entities/Core/GeoNear.cs
index 441567be3..cddf561d2 100644
--- a/MongoDB.Entities/Core/GeoNear.cs
+++ b/MongoDB.Entities/Core/GeoNear.cs
@@ -49,7 +49,7 @@ public static GeoJsonPoint<GeoJson2DGeographicCoordinates> GeoJsonPoint(double l
     public class GeoNear<T> where T : IEntity
     {
 #pragma warning disable IDE1006
-        public Coordinates2D near { get; set; }
+        public Coordinates2D near { get; set; } = null!;
         public string? distanceField { get; set; }
         public bool spherical { get; set; }
         [BsonIgnoreIfNull] public int? limit { get; set; }
@@ -61,13 +61,13 @@ public class GeoNear<T> where T : IEntity
         [BsonIgnoreIfNull] public string? key { get; set; }
 #pragma warning restore IDE1006
 
-        internal IAggregateFluent<T> ToFluent(DBContext context, AggregateOptions? options = null)
+        internal IAggregateFluent<T> ToFluent(DBContext context, AggregateOptions? options = null, string? collectionName = null, IMongoCollection<T>? collection = null)
         {
             var stage = new BsonDocument { { "$geoNear", this.ToBsonDocument() } };
 
             return context.Session == null
-                    ? context.CollectionFor<T>().Aggregate(options).AppendStage<T>(stage)
-                    : context.CollectionFor<T>().Aggregate(context.Session, options).AppendStage<T>(stage);
+                    ? context.Collection(collectionName, collection).Aggregate(options).AppendStage<T>(stage)
+                    : context.Collection(collectionName, collection).Aggregate(context.Session, options).AppendStage<T>(stage);
         }
     }
 }
diff --git a/MongoDB.Entities/Core/Logic.cs b/MongoDB.Entities/Core/Logic.cs
index 16c6ba9e5..abb12cd7d 100644
--- a/MongoDB.Entities/Core/Logic.cs
+++ b/MongoDB.Entities/Core/Logic.cs
@@ -14,7 +14,7 @@ internal static IEnumerable<UpdateDefinition<T>> BuildUpdateDefs<T>(T entity, DB
             if (entity == null)
                 throw new ArgumentException("The supplied entity cannot be null!");
 
-            var props = (context?.Cache<T>() ?? Cache<T>.Instance).UpdatableProps(entity);
+            var props = (context?.Cache<T>() ?? EntityCache<T>.Instance).UpdatableProps(entity);
 
             return props.Select(p => Builders<T>.Update.Set(p.Name, p.GetValue(entity)));
         }
@@ -27,7 +27,7 @@ internal static IEnumerable<UpdateDefinition<T>> BuildUpdateDefs<T>(T entity, Ex
             if (!propNames.Any())
                 throw new ArgumentException("Unable to get any properties from the members expression!");
 
-            var props = (context?.Cache<T>() ?? Cache<T>.Instance).UpdatableProps(entity);
+            var props = (context?.Cache<T>() ?? EntityCache<T>.Instance).UpdatableProps(entity);
 
             if (excludeMode)
                 props = props.Where(p => !propNames.Contains(p.Name));
@@ -42,7 +42,7 @@ internal static FilterDefinition<T> MergeWithGlobalFilter<T>(bool ignoreGlobalFi
             //WARNING: this has to do the same thing as DBContext.Pipeline.MergeWithGlobalFilter method
             //         if the following logic changes, update the other method also
 
-            if (!ignoreGlobalFilters && globalFilters?.Count > 0 && globalFilters.TryGetValue(typeof(T), out var gFilter))
+            if (!ignoreGlobalFilters && globalFilters is not null && globalFilters.Count > 0 && globalFilters.TryGetValue(typeof(T), out var gFilter))
             {
                 switch (gFilter.filterDef)
                 {
diff --git a/MongoDB.Entities/Core/Prop.cs b/MongoDB.Entities/Core/Prop.cs
index fcf8a551b..81a92d6a1 100644
--- a/MongoDB.Entities/Core/Prop.cs
+++ b/MongoDB.Entities/Core/Prop.cs
@@ -62,7 +62,7 @@ internal static string GetPath(string expString)
         /// <typeparam name="T">The type of the entity to get the collection name of</typeparam>
         public static string Collection<T>() where T : IEntity
         {
-            return Cache<T>.CollectionName;
+            return EntityCache<T>.CollectionName;
         }
 
         /// <summary>
diff --git a/MongoDB.Entities/Core/SequenceCounter.cs b/MongoDB.Entities/Core/SequenceCounter.cs
index e2f10dbb3..1331b3e47 100644
--- a/MongoDB.Entities/Core/SequenceCounter.cs
+++ b/MongoDB.Entities/Core/SequenceCounter.cs
@@ -7,7 +7,7 @@ namespace MongoDB.Entities
     internal class SequenceCounter : IEntity
     {
         [BsonId]
-        public string ID { get; set; }
+        public string ID { get; set; } = null!;
 
         [BsonRepresentation(BsonType.Int64)]
         public ulong Count { get; set; }
diff --git a/MongoDB.Entities/Core/Watcher.cs b/MongoDB.Entities/Core/Watcher.cs
index 7ffff7dff..42397fccf 100644
--- a/MongoDB.Entities/Core/Watcher.cs
+++ b/MongoDB.Entities/Core/Watcher.cs
@@ -29,32 +29,32 @@ public class Watcher<T> where T : IEntity
         /// <summary>
         /// This event is fired when the desired types of events have occured. Will have a list of 'entities' that was received as input.
         /// </summary>
-        public event Action<IEnumerable<T>> OnChanges;
+        public event Action<IEnumerable<T>>? OnChanges;
 
         /// <summary>
         /// This event is fired when the desired types of events have occured. Will have a list of 'entities' that was received as input.
         /// </summary>
-        public event AsyncEventHandler<IEnumerable<T>> OnChangesAsync;
+        public event AsyncEventHandler<IEnumerable<T>>? OnChangesAsync;
 
         /// <summary>
         /// This event is fired when the desired types of events have occured. Will have a list of 'ChangeStreamDocuments' that was received as input.
         /// </summary>
-        public event Action<IEnumerable<ChangeStreamDocument<T>>> OnChangesCSD;
+        public event Action<IEnumerable<ChangeStreamDocument<T>>>? OnChangesCSD;
 
         /// <summary>
         /// This event is fired when the desired types of events have occured. Will have a list of 'ChangeStreamDocuments' that was received as input.
         /// </summary>
-        public event AsyncEventHandler<IEnumerable<ChangeStreamDocument<T>>> OnChangesCSDAsync;
+        public event AsyncEventHandler<IEnumerable<ChangeStreamDocument<T>>>? OnChangesCSDAsync;
 
         /// <summary>
         /// This event is fired when an exception is thrown in the change-stream.
         /// </summary>
-        public event Action<Exception> OnError;
+        public event Action<Exception>? OnError;
 
         /// <summary>
         /// This event is fired when the internal cursor get closed due to an 'invalidate' event or cancellation is requested via the cancellation token.
         /// </summary>
-        public event Action OnStop;
+        public event Action? OnStop;
 
         /// <summary>
         /// The name of this watcher instance
@@ -70,24 +70,23 @@ public class Watcher<T> where T : IEntity
         /// Returns true if watching can be restarted if it was stopped due to an error or invalidate event.
         /// Will always return false after cancellation is requested via the cancellation token.
         /// </summary>
-        public bool CanRestart { get => !cancelToken.IsCancellationRequested; }
+        public bool CanRestart { get => !_cancelToken.IsCancellationRequested; }
 
         /// <summary>
         /// The last resume token received from mongodb server. Can be used to resume watching with .StartWithToken() method.
         /// </summary>
-        public BsonDocument ResumeToken => options?.StartAfter;
+        public BsonDocument? ResumeToken => _options?.StartAfter;
 
-        private PipelineDefinition<ChangeStreamDocument<T>, ChangeStreamDocument<T>> pipeline;
-        private ChangeStreamOptions options;
-        private bool resume;
-        private CancellationToken cancelToken;
+        private PipelineDefinition<ChangeStreamDocument<T>, ChangeStreamDocument<T>>? _pipeline;
+        private ChangeStreamOptions? _options;
+        private bool _resume;
+        private CancellationToken _cancelToken;
         private bool _initialized;
-        private readonly string tenantPrefix;
-
-        internal Watcher(string name, string tenantPrefix)
+        private readonly IMongoCollection<T> _collection;
+        internal Watcher(string name, DBContext context, IMongoCollection<T> collection)
         {
             Name = name;
-            this.tenantPrefix = tenantPrefix;
+            _collection = collection;
         }
 
         /// <summary>
@@ -101,7 +100,7 @@ internal Watcher(string name, string tenantPrefix)
         /// <param name="cancellation">A cancellation token for ending the watching/change stream</param>
         public void Start(
             EventType eventTypes,
-            Expression<Func<ChangeStreamDocument<T>, bool>> filter = null,
+            Expression<Func<ChangeStreamDocument<T>, bool>>? filter = null,
             int batchSize = 25,
             bool onlyGetIDs = false,
             bool autoResume = true,
@@ -119,8 +118,8 @@ public void Start(
         /// <param name="cancellation">A cancellation token for ending the watching/change stream</param>
         public void Start(
             EventType eventTypes,
-            Expression<Func<T, T>> projection,
-            Expression<Func<ChangeStreamDocument<T>, bool>> filter = null,
+            Expression<Func<T, T>>? projection,
+            Expression<Func<ChangeStreamDocument<T>, bool>>? filter = null,
             int batchSize = 25,
             bool autoResume = true,
             CancellationToken cancellation = default)
@@ -174,7 +173,7 @@ public void Start(
         public void StartWithToken(
             BsonDocument resumeToken,
             EventType eventTypes,
-            Expression<Func<ChangeStreamDocument<T>, bool>> filter = null,
+            Expression<Func<ChangeStreamDocument<T>, bool>>? filter = null,
             int batchSize = 25,
             bool onlyGetIDs = false,
             CancellationToken cancellation = default)
@@ -193,7 +192,7 @@ public void StartWithToken(
             BsonDocument resumeToken,
             EventType eventTypes,
             Expression<Func<T, T>> projection,
-            Expression<Func<ChangeStreamDocument<T>, bool>> filter = null,
+            Expression<Func<ChangeStreamDocument<T>, bool>>? filter = null,
             int batchSize = 25,
             CancellationToken cancellation = default)
         => Init(resumeToken, eventTypes, filter, projection, batchSize, false, true, cancellation);
@@ -235,10 +234,10 @@ public void StartWithToken(
         => Init(resumeToken, eventTypes, filter(Builders<ChangeStreamDocument<T>>.Filter), projection, batchSize, false, true, cancellation);
 
         private void Init(
-            BsonDocument resumeToken,
+            BsonDocument? resumeToken,
             EventType eventTypes,
             FilterDefinition<ChangeStreamDocument<T>> filter,
-            Expression<Func<T, T>> projection,
+            Expression<Func<T, T>>? projection,
             int batchSize,
             bool onlyGetIDs,
             bool autoResume,
@@ -247,8 +246,8 @@ private void Init(
             if (_initialized)
                 throw new InvalidOperationException("This watcher has already been initialized!");
 
-            resume = autoResume;
-            cancelToken = cancellation;
+            _resume = autoResume;
+            _cancelToken = cancellation;
 
             var ops = new List<ChangeStreamOperationType>(3) { ChangeStreamOperationType.Invalidate };
 
@@ -303,9 +302,9 @@ private void Init(
             if (projection != null)
                 stages.Add(PipelineStageDefinitionBuilder.Project(BuildProjection(projection)));
 
-            pipeline = stages;
+            _pipeline = stages;
 
-            options = new ChangeStreamOptions
+            _options = new ChangeStreamOptions
             {
                 StartAfter = resumeToken,
                 BatchSize = batchSize,
@@ -349,7 +348,7 @@ private static ProjectionDefinition<ChangeStreamDocument<T>, ChangeStreamDocumen
         /// If the watcher stopped due to an error or invalidate event, you can try to restart the watching again with this method.
         /// </summary>
         /// <param name="resumeToken">An optional resume token to restart watching with</param>
-        public void ReStart(BsonDocument resumeToken = null)
+        public void ReStart(BsonDocument? resumeToken = null)
         {
             if (!CanRestart)
             {
@@ -362,11 +361,11 @@ public void ReStart(BsonDocument resumeToken = null)
             if (!_initialized)
                 throw new InvalidOperationException("This watcher was never started. Please use .Start() first!");
 
-            if (cancelToken.IsCancellationRequested)
+            if (_cancelToken.IsCancellationRequested)
                 throw new InvalidOperationException("This watcher cannot be restarted as it has been aborted/cancelled!");
 
-            if (resumeToken != null)
-                options.StartAfter = resumeToken;
+            if (resumeToken != null && _options is not null)
+                _options.StartAfter = resumeToken;
 
             StartWatching();
         }
@@ -379,81 +378,80 @@ private void StartWatching()
             //        continuations will be run on differnt threadpool threads upon re-entry.
             //        i.e. long running thread creation is useless/wasteful for async delegates.
 
-            _ = IterateCursorAsync();
 
+            _ = IterateCursorAsync();
             async Task IterateCursorAsync()
             {
                 try
                 {
-                    using (var cursor = await DB.Collection<T>(tenantPrefix).WatchAsync(pipeline, options, cancelToken).ConfigureAwait(false))
+
+                    using var cursor = await _collection.WatchAsync(_pipeline, _options, _cancelToken).ConfigureAwait(false);
+                    while (!_cancelToken.IsCancellationRequested && await cursor.MoveNextAsync(_cancelToken).ConfigureAwait(false))
                     {
-                        while (!cancelToken.IsCancellationRequested && await cursor.MoveNextAsync(cancelToken).ConfigureAwait(false))
+                        if (cursor.Current.Any())
                         {
-                            if (cursor.Current.Any())
+                            if (_resume && _options is not null)
+                                _options.StartAfter = cursor.Current.Last().ResumeToken;
+
+                            if (OnChangesAsync != null)
                             {
-                                if (resume)
-                                    options.StartAfter = cursor.Current.Last().ResumeToken;
-
-                                if (OnChangesAsync != null)
-                                {
-                                    await OnChangesAsync.InvokeAllAsync(
-                                        cursor.Current
-                                              .Where(d => d.OperationType != ChangeStreamOperationType.Invalidate)
-                                              .Select(d => d.FullDocument)
-                                    ).ConfigureAwait(false);
-                                }
-
-                                OnChanges?.Invoke(
-                                        cursor.Current
-                                              .Where(d => d.OperationType != ChangeStreamOperationType.Invalidate)
-                                              .Select(d => d.FullDocument));
-
-                                if (OnChangesCSDAsync != null)
-                                    await OnChangesCSDAsync.InvokeAllAsync(cursor.Current).ConfigureAwait(false);
-
-                                OnChangesCSD?.Invoke(cursor.Current);
+                                await OnChangesAsync.InvokeAllAsync(
+                                    cursor.Current
+                                          .Where(d => d.OperationType != ChangeStreamOperationType.Invalidate)
+                                          .Select(d => d.FullDocument)
+                                ).ConfigureAwait(false);
                             }
+
+                            OnChanges?.Invoke(
+                                    cursor.Current
+                                          .Where(d => d.OperationType != ChangeStreamOperationType.Invalidate)
+                                          .Select(d => d.FullDocument));
+
+                            if (OnChangesCSDAsync != null)
+                                await OnChangesCSDAsync.InvokeAllAsync(cursor.Current).ConfigureAwait(false);
+
+                            OnChangesCSD?.Invoke(cursor.Current);
                         }
+                    }
 
-                        OnStop?.Invoke();
+                    OnStop?.Invoke();
 
-                        if (cancelToken.IsCancellationRequested)
+                    if (_cancelToken.IsCancellationRequested)
+                    {
+                        if (OnChangesAsync != null)
                         {
-                            if (OnChangesAsync != null)
-                            {
-                                foreach (var h in OnChangesAsync.GetHandlers())
-                                    OnChangesAsync -= h;
-                            }
+                            foreach (var h in OnChangesAsync.GetHandlers())
+                                OnChangesAsync -= h;
+                        }
 
-                            if (OnChangesCSDAsync != null)
-                            {
-                                foreach (var h in OnChangesCSDAsync.GetHandlers())
-                                    OnChangesCSDAsync -= h;
-                            }
+                        if (OnChangesCSDAsync != null)
+                        {
+                            foreach (var h in OnChangesCSDAsync.GetHandlers())
+                                OnChangesCSDAsync -= h;
+                        }
 
-                            if (OnChanges != null)
-                            {
-                                foreach (Action<IEnumerable<T>> a in OnChanges.GetInvocationList())
-                                    OnChanges -= a;
-                            }
+                        if (OnChanges != null)
+                        {
+                            foreach (Action<IEnumerable<T>> a in OnChanges.GetInvocationList())
+                                OnChanges -= a;
+                        }
 
-                            if (OnChangesCSD != null)
-                            {
-                                foreach (Action<IEnumerable<ChangeStreamDocument<T>>> a in OnChangesCSD.GetInvocationList())
-                                    OnChangesCSD -= a;
-                            }
+                        if (OnChangesCSD != null)
+                        {
+                            foreach (Action<IEnumerable<ChangeStreamDocument<T>>> a in OnChangesCSD.GetInvocationList())
+                                OnChangesCSD -= a;
+                        }
 
-                            if (OnError != null)
-                            {
-                                foreach (Action<Exception> a in OnError.GetInvocationList())
-                                    OnError -= a;
-                            }
+                        if (OnError != null)
+                        {
+                            foreach (Action<Exception> a in OnError.GetInvocationList())
+                                OnError -= a;
+                        }
 
-                            if (OnStop != null)
-                            {
-                                foreach (Action a in OnStop.GetInvocationList())
-                                    OnStop -= a;
-                            }
+                        if (OnStop != null)
+                        {
+                            foreach (Action a in OnStop.GetInvocationList())
+                                OnStop -= a;
                         }
                     }
                 }
diff --git a/MongoDB.Entities/DB/DB.Collection.cs b/MongoDB.Entities/DB/DB.Collection.cs
index da292a4d4..6272f4958 100644
--- a/MongoDB.Entities/DB/DB.Collection.cs
+++ b/MongoDB.Entities/DB/DB.Collection.cs
@@ -10,18 +10,17 @@ public static partial class DB
     {
         internal static IMongoCollection<JoinRecord> GetRefCollection<T>(string name) where T : IEntity
         {
-            //no support for multi-tenancy :-(
-            return Database<T>(null).GetCollection<JoinRecord>(name);
+            return Context.GetCollection<JoinRecord>(name);
         }
 
         /// <summary>
         /// Gets the IMongoCollection for a given IEntity type.
-        /// <para>TIP: Try never to use this unless really necessary.</para>
         /// </summary>
         /// <typeparam name="T">Any class that implements IEntity</typeparam>
-        public static IMongoCollection<T> Collection<T>(string tenantPrefix = null) where T : IEntity
+        /// <param name="collectionName">Optionally use a specific collection name</param>
+        public static IMongoCollection<T> Collection<T>(string? collectionName = null) where T : IEntity
         {
-            return Cache<T>.Collection(tenantPrefix);
+            return Context.Collection<T>(collectionName);
         }
 
         /// <summary>
@@ -30,7 +29,7 @@ public static IMongoCollection<T> Collection<T>(string tenantPrefix = null) wher
         /// <typeparam name="T">The type of entity to get the collection name for</typeparam>
         public static string CollectionName<T>() where T : IEntity
         {
-            return Cache<T>.CollectionName;
+            return Context.CollectionName<T>();
         }
 
         /// <summary>
diff --git a/MongoDB.Entities/DB/DB.Count.cs b/MongoDB.Entities/DB/DB.Count.cs
index dd923c63d..56aa6c5fb 100644
--- a/MongoDB.Entities/DB/DB.Count.cs
+++ b/MongoDB.Entities/DB/DB.Count.cs
@@ -14,7 +14,6 @@ public static partial class DB
         /// </summary>
         /// <typeparam name="T">The entity type to get the count for</typeparam>
         /// <param name="cancellation">An optional cancellation token</param>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
         public static Task<long> CountEstimatedAsync<T>(CancellationToken cancellation = default) where T : IEntity
         {
             return Context.CountEstimatedAsync<T>(cancellation);
@@ -49,10 +48,8 @@ public static Task<long> CountAsync<T>(FilterDefinition<T> filter, CancellationT
         /// </summary>
         /// <typeparam name="T">The entity type to get the count for</typeparam>
         /// <param name="filter">f => f.Eq(x => x.Prop, Value) &amp; f.Gt(x => x.Prop, Value)</param>
-        /// <param name="session">An optional session if using within a transaction</param>
         /// <param name="cancellation">An optional cancellation token</param>
         /// <param name="options">An optional CountOptions object</param>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
         public static Task<long> CountAsync<T>(Func<FilterDefinitionBuilder<T>, FilterDefinition<T>> filter, CancellationToken cancellation = default, CountOptions? options = null) where T : IEntity
         {
             return Context.CountAsync(filter, cancellation, options);
diff --git a/MongoDB.Entities/DB/DB.Distinct.cs b/MongoDB.Entities/DB/DB.Distinct.cs
index 973355a7f..b5170053f 100644
--- a/MongoDB.Entities/DB/DB.Distinct.cs
+++ b/MongoDB.Entities/DB/DB.Distinct.cs
@@ -9,9 +9,8 @@ public static partial class DB
         /// </summary>
         /// <typeparam name="T">Any Entity that implements IEntity interface</typeparam>
         /// <typeparam name="TProperty">The type of the property of the entity you'd like to get unique values for</typeparam>
-        /// <param name="session">An optional session if using within a transaction</param>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static Distinct<T, TProperty> Distinct<T, TProperty>(IClientSessionHandle session = null, string tenantPrefix = null) where T : IEntity
-            => new(session, null, tenantPrefix);
+        /// <param name="collectionName">Specifiy to override the collection name</param>
+        public static Distinct<T, TProperty> Distinct<T, TProperty>(string? collectionName = null) where T : IEntity
+            => new(Context, Collection<T>(collectionName));
     }
 }
diff --git a/MongoDB.Entities/DB/DB.File.cs b/MongoDB.Entities/DB/DB.File.cs
index 89af177f1..0aef3d0b9 100644
--- a/MongoDB.Entities/DB/DB.File.cs
+++ b/MongoDB.Entities/DB/DB.File.cs
@@ -10,7 +10,7 @@ public static partial class DB
         /// </summary>
         /// <typeparam name="T">The file entity type</typeparam>
         /// <param name="ID">The ID of the file entity</param>        
-        public static DataStreamer File<T>(string ID) where T : FileEntity, new()
+        public static DataStreamer<T> File<T>(string ID) where T : FileEntity, new()
         {
             return Context.File<T>(ID);
         }
diff --git a/MongoDB.Entities/DB/DB.Find.cs b/MongoDB.Entities/DB/DB.Find.cs
index 1860cd108..02fda51c7 100644
--- a/MongoDB.Entities/DB/DB.Find.cs
+++ b/MongoDB.Entities/DB/DB.Find.cs
@@ -9,10 +9,8 @@ public static partial class DB
         /// <para>TIP: Specify your criteria using .Match() .Sort() .Skip() .Take() .Project() .Option() methods and finally call .Execute()</para>
         /// </summary>
         /// <typeparam name="T">Any class that implements IEntity</typeparam>
-        /// <param name="session">An optional session if using within a transaction</param>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static Find<T> Find<T>(IClientSessionHandle session = null, string tenantPrefix = null) where T : IEntity
-            => new(session, null, tenantPrefix);
+        public static Find<T> Find<T>(string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
+            => new(Context, collection ?? Collection<T>(collectionName));
 
         /// <summary>
         /// Represents a MongoDB Find command
@@ -20,9 +18,7 @@ public static Find<T> Find<T>(IClientSessionHandle session = null, string tenant
         /// </summary>
         /// <typeparam name="T">Any class that implements IEntity</typeparam>
         /// <typeparam name="TProjection">The type that is returned by projection</typeparam>
-        /// <param name="session">An optional session if using within a transaction</param>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static Find<T, TProjection> Find<T, TProjection>(IClientSessionHandle session = null, string tenantPrefix = null) where T : IEntity
-            => new(session, null, tenantPrefix);
+        public static Find<T, TProjection> Find<T, TProjection>(string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
+            => new(Context, collection ?? Collection<T>(collectionName));
     }
 }
diff --git a/MongoDB.Entities/DB/DB.Index.cs b/MongoDB.Entities/DB/DB.Index.cs
index 1a441866f..1598df601 100644
--- a/MongoDB.Entities/DB/DB.Index.cs
+++ b/MongoDB.Entities/DB/DB.Index.cs
@@ -1,4 +1,6 @@
-namespace MongoDB.Entities
+using MongoDB.Driver;
+
+namespace MongoDB.Entities
 {
     public static partial class DB
     {
@@ -7,10 +9,9 @@ public static partial class DB
         /// <para>TIP: Define the keys first with .Key() method and finally call the .Create() method.</para>
         /// </summary>
         /// <typeparam name="T">Any class that implements IEntity</typeparam>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static Index<T> Index<T>(string tenantPrefix = null) where T : IEntity
+        public static Index<T> Index<T>(string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
         {
-            return new Index<T>(tenantPrefix);
+            return new Index<T>(Context, collection ?? Collection<T>(collectionName));
         }
     }
 }
diff --git a/MongoDB.Entities/DB/DB.Insert.cs b/MongoDB.Entities/DB/DB.Insert.cs
index 083465294..024fbf410 100644
--- a/MongoDB.Entities/DB/DB.Insert.cs
+++ b/MongoDB.Entities/DB/DB.Insert.cs
@@ -14,15 +14,10 @@ public static partial class DB
         /// </summary>
         /// <typeparam name="T">Any class that implements IEntity</typeparam>
         /// <param name="entity">The instance to persist</param>
-        /// <param name="session">An optional session if using within a transaction</param>
         /// <param name="cancellation">And optional cancellation token</param>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static Task InsertAsync<T>(T entity, IClientSessionHandle session = null, CancellationToken cancellation = default, string tenantPrefix = null) where T : IEntity
+        public static Task InsertAsync<T>(T entity, CancellationToken cancellation = default) where T : IEntity
         {
-            PrepAndCheckIfInsert(entity);
-            return session == null
-                   ? Collection<T>(tenantPrefix).InsertOneAsync(entity, null, cancellation)
-                   : Collection<T>(tenantPrefix).InsertOneAsync(session, entity, null, cancellation);
+            return Context.InsertAsync(entity, cancellation);
         }
 
         /// <summary>
@@ -33,19 +28,9 @@ public static Task InsertAsync<T>(T entity, IClientSessionHandle session = null,
         /// <param name="session">An optional session if using within a transaction</param>
         /// <param name="cancellation">And optional cancellation token</param>
         /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static Task<BulkWriteResult<T>> InsertAsync<T>(IEnumerable<T> entities, IClientSessionHandle session = null, CancellationToken cancellation = default, string tenantPrefix = null) where T : IEntity
+        public static Task<BulkWriteResult<T>> InsertAsync<T>(IEnumerable<T> entities, CancellationToken cancellation = default) where T : IEntity
         {
-            var models = new List<WriteModel<T>>(entities.Count());
-
-            foreach (var ent in entities)
-            {
-                PrepAndCheckIfInsert(ent);
-                models.Add(new InsertOneModel<T>(ent));
-            }
-
-            return session == null
-                   ? Collection<T>(tenantPrefix).BulkWriteAsync(models, unOrdBlkOpts, cancellation)
-                   : Collection<T>(tenantPrefix).BulkWriteAsync(session, models, unOrdBlkOpts, cancellation);
+            return Context.InsertAsync(entities, cancellation);
         }
     }
 }
diff --git a/MongoDB.Entities/DB/DB.Pipeline.cs b/MongoDB.Entities/DB/DB.Pipeline.cs
index 28786e875..cf6d94fab 100644
--- a/MongoDB.Entities/DB/DB.Pipeline.cs
+++ b/MongoDB.Entities/DB/DB.Pipeline.cs
@@ -18,11 +18,9 @@ public static partial class DB
         /// <param name="session">An optional session if using within a transaction</param>
         /// <param name="cancellation">An optional cancellation token</param>
         /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static Task<IAsyncCursor<TResult>> PipelineCursorAsync<T, TResult>(Template<T, TResult> template, AggregateOptions options = null, IClientSessionHandle session = null, CancellationToken cancellation = default, string tenantPrefix = null) where T : IEntity
+        public static Task<IAsyncCursor<TResult>> PipelineCursorAsync<T, TResult>(Template<T, TResult> template, AggregateOptions? options = null, CancellationToken cancellation = default) where T : IEntity
         {
-            return session == null
-                   ? Collection<T>(tenantPrefix).AggregateAsync(template.ToPipeline(), options, cancellation)
-                   : Collection<T>(tenantPrefix).AggregateAsync(session, template.ToPipeline(), options, cancellation);
+            return Context.PipelineCursorAsync(template, options, cancellation);
         }
 
         /// <summary>
@@ -32,20 +30,10 @@ public static Task<IAsyncCursor<TResult>> PipelineCursorAsync<T, TResult>(Templa
         /// <typeparam name="TResult">The type of the resulting objects</typeparam>
         /// <param name="template">A 'Template' object with tags replaced</param>
         /// <param name="options">The options for the aggregation. This is not required.</param>
-        /// <param name="session">An optional session if using within a transaction</param>
         /// <param name="cancellation">An optional cancellation token</param>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static async Task<List<TResult>> PipelineAsync<T, TResult>(Template<T, TResult> template, AggregateOptions options = null, IClientSessionHandle session = null, CancellationToken cancellation = default, string tenantPrefix = null) where T : IEntity
+        public static Task<List<TResult>> PipelineAsync<T, TResult>(Template<T, TResult> template, AggregateOptions? options = null, CancellationToken cancellation = default) where T : IEntity
         {
-            var list = new List<TResult>();
-            using (var cursor = await PipelineCursorAsync(template, options, session, cancellation, tenantPrefix).ConfigureAwait(false))
-            {
-                while (await cursor.MoveNextAsync(cancellation).ConfigureAwait(false))
-                {
-                    list.AddRange(cursor.Current);
-                }
-            }
-            return list;
+            return Context.PipelineAsync(template, options, cancellation);
         }
 
         /// <summary>
@@ -56,19 +44,10 @@ public static async Task<List<TResult>> PipelineAsync<T, TResult>(Template<T, TR
         /// <typeparam name="TResult">The type of the resulting object</typeparam>
         /// <param name="template">A 'Template' object with tags replaced</param>
         /// <param name="options">The options for the aggregation. This is not required.</param>
-        /// <param name="session">An optional session if using within a transaction</param>
         /// <param name="cancellation">An optional cancellation token</param>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static async Task<TResult> PipelineSingleAsync<T, TResult>(Template<T, TResult> template, AggregateOptions options = null, IClientSessionHandle session = null, CancellationToken cancellation = default, string tenantPrefix = null) where T : IEntity
+        public static Task<TResult> PipelineSingleAsync<T, TResult>(Template<T, TResult> template, AggregateOptions? options = null, CancellationToken cancellation = default) where T : IEntity
         {
-            AggregateOptions opts = options ?? new AggregateOptions();
-            opts.BatchSize = 2;
-
-            using (var cursor = await PipelineCursorAsync(template, opts, session, cancellation, tenantPrefix).ConfigureAwait(false))
-            {
-                await cursor.MoveNextAsync(cancellation).ConfigureAwait(false);
-                return cursor.Current.SingleOrDefault();
-            }
+            return Context.PipelineSingleAsync(template, options, cancellation);
         }
 
         /// <summary>
@@ -78,19 +57,11 @@ public static async Task<TResult> PipelineSingleAsync<T, TResult>(Template<T, TR
         /// <typeparam name="TResult">The type of the resulting object</typeparam>
         /// <param name="template">A 'Template' object with tags replaced</param>
         /// <param name="options">The options for the aggregation. This is not required.</param>
-        /// <param name="session">An optional session if using within a transaction</param>
         /// <param name="cancellation">An optional cancellation token</param>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static async Task<TResult> PipelineFirstAsync<T, TResult>(Template<T, TResult> template, AggregateOptions options = null, IClientSessionHandle session = null, CancellationToken cancellation = default, string tenantPrefix = null) where T : IEntity
+        public static Task<TResult> PipelineFirstAsync<T, TResult>(Template<T, TResult> template, AggregateOptions? options = null, CancellationToken cancellation = default) where T : IEntity
         {
-            AggregateOptions opts = options ?? new AggregateOptions();
-            opts.BatchSize = 1;
+            return Context.PipelineFirstAsync(template, options, cancellation);
 
-            using (var cursor = await PipelineCursorAsync(template, opts, session, cancellation, tenantPrefix).ConfigureAwait(false))
-            {
-                await cursor.MoveNextAsync(cancellation).ConfigureAwait(false);
-                return cursor.Current.SingleOrDefault();
-            }
         }
     }
 }
diff --git a/MongoDB.Entities/DB/DB.Save.cs b/MongoDB.Entities/DB/DB.Save.cs
index 68dbe0919..f5a562ec7 100644
--- a/MongoDB.Entities/DB/DB.Save.cs
+++ b/MongoDB.Entities/DB/DB.Save.cs
@@ -10,8 +10,7 @@ namespace MongoDB.Entities
 {
     public static partial class DB
     {
-        private static readonly BulkWriteOptions unOrdBlkOpts = new() { IsOrdered = false };
-        private static readonly UpdateOptions updateOptions = new() { IsUpsert = true };
+
 
         /// <summary>
         /// Saves a complete entity replacing an existing entity or creating a new one if it does not exist. 
@@ -19,21 +18,10 @@ public static partial class DB
         /// </summary>
         /// <typeparam name="T">Any class that implements IEntity</typeparam>
         /// <param name="entity">The instance to persist</param>
-        /// <param name="session">An optional session if using within a transaction</param>
         /// <param name="cancellation">And optional cancellation token</param>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static Task SaveAsync<T>(T entity, IClientSessionHandle session = null, CancellationToken cancellation = default, string tenantPrefix = null) where T : IEntity
+        public static Task SaveAsync<T>(T entity, CancellationToken cancellation = default) where T : IEntity
         {
-            if (PrepAndCheckIfInsert(entity))
-            {
-                return session == null
-                       ? Collection<T>(tenantPrefix).InsertOneAsync(entity, null, cancellation)
-                       : Collection<T>(tenantPrefix).InsertOneAsync(session, entity, null, cancellation);
-            }
-
-            return session == null
-                   ? Collection<T>(tenantPrefix).ReplaceOneAsync(x => x.ID == entity.ID, entity, new ReplaceOptions { IsUpsert = true }, cancellation)
-                   : Collection<T>(tenantPrefix).ReplaceOneAsync(session, x => x.ID == entity.ID, entity, new ReplaceOptions { IsUpsert = true }, cancellation);
+            return Context.SaveAsync<T>(entity, cancellation);
         }
 
         /// <summary>
@@ -42,30 +30,10 @@ public static Task SaveAsync<T>(T entity, IClientSessionHandle session = null, C
         /// </summary>
         /// <typeparam name="T">Any class that implements IEntity</typeparam>
         /// <param name="entities">The entities to persist</param>
-        /// <param name="session">An optional session if using within a transaction</param>
         /// <param name="cancellation">And optional cancellation token</param>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static Task<BulkWriteResult<T>> SaveAsync<T>(IEnumerable<T> entities, IClientSessionHandle session = null, CancellationToken cancellation = default, string tenantPrefix = null) where T : IEntity
+        public static Task<BulkWriteResult<T>> SaveAsync<T>(IEnumerable<T> entities, CancellationToken cancellation = default) where T : IEntity
         {
-            var models = new List<WriteModel<T>>(entities.Count());
-
-            foreach (var ent in entities)
-            {
-                if (PrepAndCheckIfInsert(ent))
-                {
-                    models.Add(new InsertOneModel<T>(ent));
-                }
-                else
-                {
-                    models.Add(new ReplaceOneModel<T>(
-                        filter: Builders<T>.Filter.Eq(e => e.ID, ent.ID),
-                        replacement: ent)
-                    { IsUpsert = true });
-                }
-            }
-            return session == null
-                   ? Collection<T>(tenantPrefix).BulkWriteAsync(models, unOrdBlkOpts, cancellation)
-                   : Collection<T>(tenantPrefix).BulkWriteAsync(session, models, unOrdBlkOpts, cancellation);
+            return Context.SaveAsync(entities, cancellation);
         }
 
         /// <summary>
@@ -77,12 +45,11 @@ public static Task<BulkWriteResult<T>> SaveAsync<T>(IEnumerable<T> entities, ICl
         /// <typeparam name="T">Any class that implements IEntity</typeparam>
         /// <param name="entity">The entity to save</param>
         /// <param name="members">x => new { x.PropOne, x.PropTwo }</param>
-        /// <param name="session">An optional session if using within a transaction</param>
         /// <param name="cancellation">An optional cancellation token</param>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static Task<UpdateResult> SaveOnlyAsync<T>(T entity, Expression<Func<T, object>> members, IClientSessionHandle session = null, CancellationToken cancellation = default, string tenantPrefix = null) where T : IEntity
+        public static Task<UpdateResult> SaveOnlyAsync<T>(T entity, Expression<Func<T, object>> members, CancellationToken cancellation = default) where T : IEntity
         {
-            return SavePartial(entity, members, tenantPrefix, session, cancellation);
+            return Context.SaveOnlyAsync(entity, members, cancellation);
+
         }
 
         /// <summary>
@@ -94,12 +61,10 @@ public static Task<UpdateResult> SaveOnlyAsync<T>(T entity, Expression<Func<T, o
         /// <typeparam name="T">Any class that implements IEntity</typeparam>
         /// <param name="entities">The batch of entities to save</param>
         /// <param name="members">x => new { x.PropOne, x.PropTwo }</param>
-        /// <param name="session">An optional session if using within a transaction</param>
         /// <param name="cancellation">An optional cancellation token</param>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static Task<BulkWriteResult<T>> SaveOnlyAsync<T>(IEnumerable<T> entities, Expression<Func<T, object>> members, IClientSessionHandle session = null, CancellationToken cancellation = default, string tenantPrefix = null) where T : IEntity
+        public static Task<BulkWriteResult<T>> SaveOnlyAsync<T>(IEnumerable<T> entities, Expression<Func<T, object>> members, CancellationToken cancellation = default) where T : IEntity
         {
-            return SavePartial(entities, members, tenantPrefix, session, cancellation);
+            return Context.SaveOnlyAsync(entities, members, cancellation);
         }
 
         /// <summary>
@@ -111,12 +76,10 @@ public static Task<BulkWriteResult<T>> SaveOnlyAsync<T>(IEnumerable<T> entities,
         /// <typeparam name="T">Any class that implements IEntity</typeparam>
         /// <param name="entity">The entity to save</param>
         /// <param name="members">x => new { x.PropOne, x.PropTwo }</param>
-        /// <param name="session">An optional session if using within a transaction</param>
         /// <param name="cancellation">An optional cancellation token</param>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static Task<UpdateResult> SaveExceptAsync<T>(T entity, Expression<Func<T, object>> members, IClientSessionHandle session = null, CancellationToken cancellation = default, string tenantPrefix = null) where T : IEntity
+        public static Task<UpdateResult> SaveExceptAsync<T>(T entity, Expression<Func<T, object>> members, CancellationToken cancellation = default) where T : IEntity
         {
-            return SavePartial(entity, members, tenantPrefix, session, cancellation, true);
+            return Context.SaveExceptAsync(entity, members, cancellation);
         }
 
         /// <summary>
@@ -128,12 +91,10 @@ public static Task<UpdateResult> SaveExceptAsync<T>(T entity, Expression<Func<T,
         /// <typeparam name="T">Any class that implements IEntity</typeparam>
         /// <param name="entities">The batch of entities to save</param>
         /// <param name="members">x => new { x.PropOne, x.PropTwo }</param>
-        /// <param name="session">An optional session if using within a transaction</param>
         /// <param name="cancellation">An optional cancellation token</param>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static Task<BulkWriteResult<T>> SaveExceptAsync<T>(IEnumerable<T> entities, Expression<Func<T, object>> members, IClientSessionHandle session = null, CancellationToken cancellation = default, string tenantPrefix = null) where T : IEntity
+        public static Task<BulkWriteResult<T>> SaveExceptAsync<T>(IEnumerable<T> entities, Expression<Func<T, object>> members, CancellationToken cancellation = default) where T : IEntity
         {
-            return SavePartial(entities, members, tenantPrefix, session, cancellation, true);
+            return Context.SaveExceptAsync(entities, members, cancellation);
         }
 
         /// <summary>
@@ -142,95 +103,12 @@ public static Task<BulkWriteResult<T>> SaveExceptAsync<T>(IEnumerable<T> entitie
         /// </summary>
         /// <typeparam name="T">Any class that implements IEntity</typeparam>
         /// <param name="entity">The entity to save</param>
-        /// <param name="session">An optional session if using within a transaction</param>
         /// <param name="cancellation">An optional cancellation token</param>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static Task<UpdateResult> SavePreservingAsync<T>(T entity, IClientSessionHandle session = null, CancellationToken cancellation = default, string tenantPrefix = null) where T : IEntity
+        public static Task<UpdateResult> SavePreservingAsync<T>(T entity, CancellationToken cancellation = default) where T : IEntity
         {
-            entity.ThrowIfUnsaved();
-
-            var propsToUpdate = Cache<T>.UpdatableProps(entity);
-
-            IEnumerable<string> propsToPreserve = new string[0];
-
-            var dontProps = propsToUpdate.Where(p => p.IsDefined(typeof(DontPreserveAttribute), false)).Select(p => p.Name);
-            var presProps = propsToUpdate.Where(p => p.IsDefined(typeof(PreserveAttribute), false)).Select(p => p.Name);
-
-            if (dontProps.Any() && presProps.Any())
-                throw new NotSupportedException("[Preseve] and [DontPreserve] attributes cannot be used together on the same entity!");
-
-            if (dontProps.Any())
-                propsToPreserve = propsToUpdate.Where(p => !dontProps.Contains(p.Name)).Select(p => p.Name);
-
-            if (presProps.Any())
-                propsToPreserve = propsToUpdate.Where(p => presProps.Contains(p.Name)).Select(p => p.Name);
-
-            if (!propsToPreserve.Any())
-                throw new ArgumentException("No properties are being preserved. Please use .SaveAsync() method instead!");
-
-            propsToUpdate = propsToUpdate.Where(p => !propsToPreserve.Contains(p.Name));
-
-            var propsToUpdateCount = propsToUpdate.Count();
-
-            if (propsToUpdateCount == 0)
-                throw new ArgumentException("At least one property must be not preserved!");
-
-            var defs = new List<UpdateDefinition<T>>(propsToUpdateCount);
-
-            foreach (var p in propsToUpdate)
-            {
-                if (p.Name == Cache<T>.ModifiedOnPropName)
-                    defs.Add(Builders<T>.Update.CurrentDate(Cache<T>.ModifiedOnPropName));
-                else
-                    defs.Add(Builders<T>.Update.Set(p.Name, p.GetValue(entity)));
-            }
-
-            return
-                session == null
-                ? Collection<T>(tenantPrefix).UpdateOneAsync(e => e.ID == entity.ID, Builders<T>.Update.Combine(defs), updateOptions, cancellation)
-                : Collection<T>(tenantPrefix).UpdateOneAsync(session, e => e.ID == entity.ID, Builders<T>.Update.Combine(defs), updateOptions, cancellation);
+            return Context.SavePreservingAsync(entity, cancellation);
         }
 
-        private static Task<UpdateResult> SavePartial<T>(T entity, Expression<Func<T, object>> members, string tenantPrefix, IClientSessionHandle session, CancellationToken cancellation, bool excludeMode = false) where T : IEntity
-        {
-            PrepAndCheckIfInsert(entity); //just prep. we don't care about inserts here
-            return
-                session == null
-                ? Collection<T>(tenantPrefix).UpdateOneAsync(e => e.ID == entity.ID, Builders<T>.Update.Combine(Logic.BuildUpdateDefs(entity, members, excludeMode)), updateOptions, cancellation)
-                : Collection<T>(tenantPrefix).UpdateOneAsync(session, e => e.ID == entity.ID, Builders<T>.Update.Combine(Logic.BuildUpdateDefs(entity, members, excludeMode)), updateOptions, cancellation);
-        }
-
-        private static Task<BulkWriteResult<T>> SavePartial<T>(IEnumerable<T> entities, Expression<Func<T, object>> members, string tenantPrefix, IClientSessionHandle session, CancellationToken cancellation, bool excludeMode = false) where T : IEntity
-        {
-            var models = new List<WriteModel<T>>(entities.Count());
 
-            foreach (var ent in entities)
-            {
-                PrepAndCheckIfInsert(ent); //just prep. we don't care about inserts here
-                models.Add(
-                    new UpdateOneModel<T>(
-                            filter: Builders<T>.Filter.Eq(e => e.ID, ent.ID),
-                            update: Builders<T>.Update.Combine(Logic.BuildUpdateDefs(ent, members, excludeMode)))
-                    { IsUpsert = true });
-            }
-
-            return session == null
-                ? Collection<T>(tenantPrefix).BulkWriteAsync(models, unOrdBlkOpts, cancellation)
-                : Collection<T>(tenantPrefix).BulkWriteAsync(session, models, unOrdBlkOpts, cancellation);
-        }
-
-        private static bool PrepAndCheckIfInsert<T>(T entity) where T : IEntity
-        {
-            if (string.IsNullOrEmpty(entity.ID))
-            {
-                entity.ID = entity.GenerateNewID();
-                if (Cache<T>.HasCreatedOn) ((ICreatedOn)entity).CreatedOn = DateTime.UtcNow;
-                if (Cache<T>.HasModifiedOn) ((IModifiedOn)entity).ModifiedOn = DateTime.UtcNow;
-                return true;
-            }
-
-            if (Cache<T>.HasModifiedOn) ((IModifiedOn)entity).ModifiedOn = DateTime.UtcNow;
-            return false;
-        }
     }
 }
diff --git a/MongoDB.Entities/DB/DB.Sequence.cs b/MongoDB.Entities/DB/DB.Sequence.cs
index 739a0c14e..05bd537bb 100644
--- a/MongoDB.Entities/DB/DB.Sequence.cs
+++ b/MongoDB.Entities/DB/DB.Sequence.cs
@@ -12,10 +12,9 @@ public static partial class DB
         /// </summary>
         /// <typeparam name="T">The type of entity to get the next sequential number for</typeparam>
         /// <param name="cancellation">An optional cancellation token</param>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static Task<ulong> NextSequentialNumberAsync<T>(CancellationToken cancellation = default, string tenantPrefix = null) where T : IEntity
+        public static Task<ulong> NextSequentialNumberAsync<T>(CancellationToken cancellation = default) where T : IEntity
         {
-            return NextSequentialNumberAsync(CollectionName<T>(), cancellation, tenantPrefix);
+            return Context.NextSequentialNumberAsync<T>(cancellation);
         }
 
         /// <summary>
@@ -23,15 +22,9 @@ public static Task<ulong> NextSequentialNumberAsync<T>(CancellationToken cancell
         /// </summary>
         /// <param name="sequenceName">The name of the sequence to get the next number for</param>
         /// <param name="cancellation">An optional cancellation token</param>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static Task<ulong> NextSequentialNumberAsync(string sequenceName, CancellationToken cancellation = default, string tenantPrefix = null)
+        public static Task<ulong> NextSequentialNumberAsync(string sequenceName, CancellationToken cancellation = default)
         {
-            return new UpdateAndGet<SequenceCounter, ulong>(null, null, null, tenantPrefix)
-                .Match(s => s.ID == sequenceName)
-                .Modify(b => b.Inc(s => s.Count, 1ul))
-                .Option(o => o.IsUpsert = true)
-                .Project(s => s.Count)
-                .ExecuteAsync(cancellation);
+            return Context.NextSequentialNumberAsync(sequenceName, cancellation);
         }
     }
 }
diff --git a/MongoDB.Entities/DB/DB.Watcher.cs b/MongoDB.Entities/DB/DB.Watcher.cs
index 6758c6540..0776c751a 100644
--- a/MongoDB.Entities/DB/DB.Watcher.cs
+++ b/MongoDB.Entities/DB/DB.Watcher.cs
@@ -11,21 +11,15 @@ public static partial class DB
         /// </summary>
         /// <typeparam name="T">The entity type to get a watcher for</typeparam>
         /// <param name="name">A unique name for the watcher of this entity type. Names can be duplicate among different entity types.</param>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static Watcher<T> Watcher<T>(string name, string tenantPrefix = null) where T : IEntity
+        public static Watcher<T> Watcher<T>(string name) where T : IEntity
         {
-            if (Cache<T>.Watchers.TryGetValue(name.ToLower().Trim(), out Watcher<T> watcher))
-                return watcher;
-
-            watcher = new Watcher<T>(name.ToLower().Trim(), tenantPrefix);
-            Cache<T>.Watchers.TryAdd(name, watcher);
-            return watcher;
+            return Context.Watcher<T>(name);
         }
 
         /// <summary>
         /// Returns all the watchers for a given entity type
         /// </summary>
         /// <typeparam name="T">The entity type to get the watcher of</typeparam>
-        public static IEnumerable<Watcher<T>> Watchers<T>() where T : IEntity => Cache<T>.Watchers.Values;
+        public static IEnumerable<Watcher<T>> Watchers<T>() where T : IEntity => Context.Cache<T>().Watchers.Values;
     }
 }
diff --git a/MongoDB.Entities/DB/DB.cs b/MongoDB.Entities/DB/DB.cs
index 499fbcdc4..fc6b72146 100644
--- a/MongoDB.Entities/DB/DB.cs
+++ b/MongoDB.Entities/DB/DB.cs
@@ -13,27 +13,30 @@ namespace MongoDB.Entities
     /// <summary>
     /// The main entrypoint for all data access methods of the library
     /// </summary>
+    /// <remarks>Please consider using DBContext directly, this will be made obsolete in the future</remarks>
     public static partial class DB
-    {
+    {
+        private static DBContext? _context;
+
         static DB()
-        {
-            BsonSerializer.RegisterSerializer(new DateSerializer());
-            BsonSerializer.RegisterSerializer(new FuzzyStringSerializer());
-            BsonSerializer.RegisterSerializer(typeof(decimal), new DecimalSerializer(BsonType.Decimal128));
-            BsonSerializer.RegisterSerializer(typeof(decimal?), new NullableSerializer<decimal>(new DecimalSerializer(BsonType.Decimal128)));
-
-            ConventionRegistry.Register(
-                "DefaultConventions",
-                new ConventionPack
-                {
-                        new IgnoreExtraElementsConvention(true),
-                        new IgnoreManyPropsConvention()
-                },
-                _ => true);
+        {
+            DBContext.InitStatic();
         }
 
-        //TODO: refactor api
-        public static DBContext Context { get; set; }
+        /// <summary>
+        /// Checks if InitAsync was called successfully
+        /// </summary>
+        public static bool IsInitialized => _context is not null;
+
+        /// <summary>
+        /// Contains the latest initialized context
+        /// </summary>
+        /// <exception cref="ArgumentException">Throws an exception if InitAsync wasn't called, check <see cref="IsInitialized"/></exception>
+        public static DBContext Context
+        {
+            get => _context ?? throw new ArgumentException("The database hasn't been initialized yet! please call [InitAsync] first");
+            set => _context = value;
+        }
 
         /// <summary>
         /// Initializes a MongoDB connection with the given connection parameters.
@@ -42,48 +45,62 @@ static DB()
         /// </summary>
         /// <param name="database">Name of the database</param>
         /// <param name="host">Address of the MongoDB server</param>
-        /// <param name="port">Port number of the server</param>
-        public static Task InitAsync(string database, string host = "127.0.0.1", int port = 27017)
+        /// <param name="port">Port number of the server</param>
+        /// <param name="skipNetworkPing">Whether to skip pinging the host on initialization, in which case the task completes instantly</param>
+        public static Task InitAsync(string database, string host = "127.0.0.1", int port = 27017, bool skipNetworkPing = false)
         {
             return Initialize(
-                new MongoClientSettings { Server = new MongoServerAddress(host, port) }, database);
-        }
-
+                new MongoClientSettings { Server = new MongoServerAddress(host, port) }, database, skipNetworkPing);
+        }
+
         /// <summary>
         /// Initializes a MongoDB connection with the given connection parameters.
         /// <para>WARNING: will throw an error if server is not reachable!</para>
         /// You can call this method as many times as you want (such as in serverless functions) with the same parameters and the connections won't get duplicated.
         /// </summary>
         /// <param name="database">Name of the database</param>
-        /// <param name="settings">A MongoClientSettings object</param>
-        public static Task InitAsync(string database, MongoClientSettings settings)
+        /// <param name="settings">A MongoClientSettings object</param>
+        /// <param name="skipNetworkPing">Whether to skip pinging the host on initialization, in which case the task completes instantly</param>        
+        public static Task InitAsync(string database, MongoClientSettings settings, bool skipNetworkPing = false)
         {
-            return Initialize(settings, database);
-        }
-
+            return Initialize(settings, database, skipNetworkPing);
+        }
+
+        /// <summary>
+        /// Initializes a MongoDB connection with the given DBContext parameters.
+        /// <para>WARNING: will throw an error if server is not reachable!</para>
+        /// </summary>
+        /// <param name="context">The database context</param>
+        /// <param name="skipNetworkPing">Whether to skip pinging the host on initialization, in which case the task completes instantly</param>
+        public static async Task InitAsync(DBContext context, bool skipNetworkPing = false)
+        {
+            if (skipNetworkPing || await context.PingNetwork())
+            {
+                _context = context;
+            }
+            else
+            {
+                _context = null;
+            }
+        }
+
+
         internal static async Task Initialize(MongoClientSettings settings, string dbName, bool skipNetworkPing = false)
         {
             if (string.IsNullOrEmpty(dbName))
-                throw new ArgumentNullException(nameof(dbName), "Database name cannot be empty!");
-
-            if (dbs.ContainsKey(dbName))
-                return;
-
-            try
-            {
-                var db = new MongoClient(settings).GetDatabase(dbName);
+                throw new ArgumentNullException(nameof(dbName), "Database name cannot be empty!");
 
-                if (dbs.Count == 0)
-                    defaultDb = db;
-
-                if (dbs.TryAdd(dbName, db) && !skipNetworkPing)
-                    await db.RunCommandAsync((Command<BsonDocument>)"{ping:1}").ConfigureAwait(false);
-            }
-            catch (Exception)
-            {
-                dbs.TryRemove(dbName, out _);
-                throw;
-            }
+            if (dbName == _context?.DatabaseNamespace.DatabaseName) return;
+
+            var newCtx = new DBContext(dbName, settings);
+            if (skipNetworkPing || await newCtx.PingNetwork())
+            {
+                _context = newCtx;
+            }
+            else
+            {
+                _context = null;
+            }
         }
 
         /// <summary>
@@ -114,19 +131,19 @@ public static async Task<IEnumerable<string>> AllDatabaseNamesAsync(MongoClientS
         /// </summary>
         /// <typeparam name="T">Any class that implements IEntity</typeparam>
         /// <param name="databaseName">The name of the database</param>
+        [Obsolete("This method does nothing", error: true)]
         public static void DatabaseFor<T>(string databaseName) where T : IEntity
         {
-            Cache.MapTypeToDbNameWithoutTenantPrefix<T>(databaseName);
         }
 
         /// <summary>
         /// Gets the IMongoDatabase for the given entity type
         /// </summary>
         /// <typeparam name="T">The type of entity</typeparam>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static IMongoDatabase Database<T>(string tenantPrefix = null) where T : IEntity
+        [Obsolete("This method returns the current Context", error: true)]
+        public static IMongoDatabase Database<T>() where T : IEntity
         {
-            return Cache<T>.Collection(tenantPrefix).Database;
+            return Context;
         }
 
         /// <summary>
@@ -134,32 +151,19 @@ public static IMongoDatabase Database<T>(string tenantPrefix = null) where T : I
         /// You can also get the default database by passing 'default' or 'null' for the name parameter.
         /// </summary>
         /// <param name="name">The name of the database to retrieve</param>
-        public static IMongoDatabase Database(string name)
+        public static IMongoDatabase Database(string? name)
         {
-            IMongoDatabase db = null;
-
-            if (dbs.Count > 0)
-            {
-                if (string.IsNullOrEmpty(name))
-                    db = defaultDb;
-                else
-                    dbs.TryGetValue(name, out db);
-            }
-
-            if (db == null)
-                throw new InvalidOperationException($"Database connection is not initialized for [{(string.IsNullOrEmpty(name) ? "Default" : name)}]");
-
-            return db;
+            return name == null ? Context : Context.MongoServerContext.GetDatabase(name);
         }
 
         /// <summary>
         /// Gets the name of the database a given entity type is attached to. Returns name of default database if not specifically attached.
         /// </summary>
         /// <typeparam name="T">Any class that implements IEntity</typeparam>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static string DatabaseName<T>(string tenantPrefix = null) where T : IEntity
+        [Obsolete("This method returns the current DatabaseName in the Context")]
+        public static string DatabaseName<T>() where T : IEntity
         {
-            return Database<T>(tenantPrefix).DatabaseNamespace.DatabaseName;
+            return Context.DatabaseNamespace.DatabaseName;
         }
 
         /// <summary>
diff --git a/MongoDB.Entities/DBCollection/DBCollection.IMongoCollection.cs b/MongoDB.Entities/DBCollection/DBCollection.IMongoCollection.cs
new file mode 100644
index 000000000..017a4af7b
--- /dev/null
+++ b/MongoDB.Entities/DBCollection/DBCollection.IMongoCollection.cs
@@ -0,0 +1,487 @@
+using MongoDB.Bson;
+using MongoDB.Bson.Serialization;
+using MongoDB.Driver;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace MongoDB.Entities;
+
+public partial class DBCollection<T>
+{
+    public CollectionNamespace CollectionNamespace => Collection.CollectionNamespace;
+
+    public IMongoDatabase Database => Collection.Database;
+
+    public IBsonSerializer<T> DocumentSerializer => Collection.DocumentSerializer;
+
+    public IMongoIndexManager<T> Indexes => Collection.Indexes;
+
+    public MongoCollectionSettings Settings => Collection.Settings;
+
+    public IAsyncCursor<TResult> Aggregate<TResult>(PipelineDefinition<T, TResult> pipeline, AggregateOptions? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.Aggregate(pipeline, options, cancellationToken);
+    }
+
+    public IAsyncCursor<TResult> Aggregate<TResult>(IClientSessionHandle session, PipelineDefinition<T, TResult> pipeline, AggregateOptions? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.Aggregate(session, pipeline, options, cancellationToken);
+    }
+
+    public Task<IAsyncCursor<TResult>> AggregateAsync<TResult>(PipelineDefinition<T, TResult> pipeline, AggregateOptions? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.AggregateAsync(pipeline, options, cancellationToken);
+    }
+
+    public Task<IAsyncCursor<TResult>> AggregateAsync<TResult>(IClientSessionHandle session, PipelineDefinition<T, TResult> pipeline, AggregateOptions? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.AggregateAsync(session, pipeline, options, cancellationToken);
+    }
+
+    public void AggregateToCollection<TResult>(PipelineDefinition<T, TResult> pipeline, AggregateOptions? options = null, CancellationToken cancellationToken = default)
+    {
+        Collection.AggregateToCollection(pipeline, options, cancellationToken);
+    }
+
+    public void AggregateToCollection<TResult>(IClientSessionHandle session, PipelineDefinition<T, TResult> pipeline, AggregateOptions? options = null, CancellationToken cancellationToken = default)
+    {
+        Collection.AggregateToCollection(session, pipeline, options, cancellationToken);
+    }
+
+    public Task AggregateToCollectionAsync<TResult>(PipelineDefinition<T, TResult> pipeline, AggregateOptions? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.AggregateToCollectionAsync(pipeline, options, cancellationToken);
+    }
+
+    public Task AggregateToCollectionAsync<TResult>(IClientSessionHandle session, PipelineDefinition<T, TResult> pipeline, AggregateOptions? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.AggregateToCollectionAsync(session, pipeline, options, cancellationToken);
+    }
+
+    public BulkWriteResult<T> BulkWrite(IEnumerable<WriteModel<T>> requests, BulkWriteOptions? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.BulkWrite(requests, options, cancellationToken);
+    }
+
+    public BulkWriteResult<T> BulkWrite(IClientSessionHandle session, IEnumerable<WriteModel<T>> requests, BulkWriteOptions? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.BulkWrite(session, requests, options, cancellationToken);
+    }
+
+    public Task<BulkWriteResult<T>> BulkWriteAsync(IEnumerable<WriteModel<T>> requests, BulkWriteOptions? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.BulkWriteAsync(requests, options, cancellationToken);
+    }
+
+    public Task<BulkWriteResult<T>> BulkWriteAsync(IClientSessionHandle session, IEnumerable<WriteModel<T>> requests, BulkWriteOptions? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.BulkWriteAsync(session, requests, options, cancellationToken);
+    }
+
+    [Obsolete("Use CountDocuments or EstimatedDocumentCount instead.")]
+    long IMongoCollection<T>.Count(FilterDefinition<T> filter, CountOptions options, CancellationToken cancellationToken)
+    {
+        return Collection.Count(filter, options, cancellationToken);
+    }
+
+    [Obsolete("Use CountDocuments or EstimatedDocumentCount instead.")]
+    long IMongoCollection<T>.Count(IClientSessionHandle session, FilterDefinition<T> filter, CountOptions options, CancellationToken cancellationToken)
+    {
+        return Collection.Count(session, filter, options, cancellationToken);
+    }
+
+    [Obsolete("Use CountDocumentsAsync or EstimatedDocumentCountAsync instead.")]
+    Task<long> IMongoCollection<T>.CountAsync(FilterDefinition<T> filter, CountOptions? options, CancellationToken cancellationToken)
+    {
+        return Collection.CountAsync(filter, options, cancellationToken);
+    }
+
+    [Obsolete("Use CountDocumentsAsync or EstimatedDocumentCountAsync instead.")]
+    Task<long> IMongoCollection<T>.CountAsync(IClientSessionHandle session, FilterDefinition<T> filter, CountOptions? options, CancellationToken cancellationToken)
+    {
+        return Collection.CountAsync(session, filter, options, cancellationToken);
+    }
+
+    public long CountDocuments(FilterDefinition<T> filter, CountOptions? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.CountDocuments(filter, options, cancellationToken);
+    }
+
+    public long CountDocuments(IClientSessionHandle session, FilterDefinition<T> filter, CountOptions? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.CountDocuments(session, filter, options, cancellationToken);
+    }
+
+    public Task<long> CountDocumentsAsync(FilterDefinition<T> filter, CountOptions? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.CountDocumentsAsync(filter, options, cancellationToken);
+    }
+
+    public Task<long> CountDocumentsAsync(IClientSessionHandle session, FilterDefinition<T> filter, CountOptions? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.CountDocumentsAsync(session, filter, options, cancellationToken);
+    }
+
+    public DeleteResult DeleteMany(FilterDefinition<T> filter, CancellationToken cancellationToken = default)
+    {
+        return Collection.DeleteMany(filter, cancellationToken);
+    }
+
+    public DeleteResult DeleteMany(FilterDefinition<T> filter, DeleteOptions options, CancellationToken cancellationToken = default)
+    {
+        return Collection.DeleteMany(filter, options, cancellationToken);
+    }
+
+    public DeleteResult DeleteMany(IClientSessionHandle session, FilterDefinition<T> filter, DeleteOptions? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.DeleteMany(session, filter, options, cancellationToken);
+    }
+
+    public Task<DeleteResult> DeleteManyAsync(FilterDefinition<T> filter, CancellationToken cancellationToken = default)
+    {
+        return Collection.DeleteManyAsync(filter, cancellationToken);
+    }
+
+    public Task<DeleteResult> DeleteManyAsync(FilterDefinition<T> filter, DeleteOptions options, CancellationToken cancellationToken = default)
+    {
+        return Collection.DeleteManyAsync(filter, options, cancellationToken);
+    }
+
+    public Task<DeleteResult> DeleteManyAsync(IClientSessionHandle session, FilterDefinition<T> filter, DeleteOptions? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.DeleteManyAsync(session, filter, options, cancellationToken);
+    }
+
+    public DeleteResult DeleteOne(FilterDefinition<T> filter, CancellationToken cancellationToken = default)
+    {
+        return Collection.DeleteOne(filter, cancellationToken);
+    }
+
+    public DeleteResult DeleteOne(FilterDefinition<T> filter, DeleteOptions options, CancellationToken cancellationToken = default)
+    {
+        return Collection.DeleteOne(filter, options, cancellationToken);
+    }
+
+    public DeleteResult DeleteOne(IClientSessionHandle session, FilterDefinition<T> filter, DeleteOptions? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.DeleteOne(session, filter, options, cancellationToken);
+    }
+
+    public Task<DeleteResult> DeleteOneAsync(FilterDefinition<T> filter, CancellationToken cancellationToken = default)
+    {
+        return Collection.DeleteOneAsync(filter, cancellationToken);
+    }
+
+    public Task<DeleteResult> DeleteOneAsync(FilterDefinition<T> filter, DeleteOptions options, CancellationToken cancellationToken = default)
+    {
+        return Collection.DeleteOneAsync(filter, options, cancellationToken);
+    }
+
+    public Task<DeleteResult> DeleteOneAsync(IClientSessionHandle session, FilterDefinition<T> filter, DeleteOptions? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.DeleteOneAsync(session, filter, options, cancellationToken);
+    }
+
+    public IAsyncCursor<TField> Distinct<TField>(FieldDefinition<T, TField> field, FilterDefinition<T> filter, DistinctOptions? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.Distinct(field, filter, options, cancellationToken);
+    }
+
+    public IAsyncCursor<TField> Distinct<TField>(IClientSessionHandle session, FieldDefinition<T, TField> field, FilterDefinition<T> filter, DistinctOptions? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.Distinct(session, field, filter, options, cancellationToken);
+    }
+
+    public Task<IAsyncCursor<TField>> DistinctAsync<TField>(FieldDefinition<T, TField> field, FilterDefinition<T> filter, DistinctOptions? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.DistinctAsync(field, filter, options, cancellationToken);
+    }
+
+    public Task<IAsyncCursor<TField>> DistinctAsync<TField>(IClientSessionHandle session, FieldDefinition<T, TField> field, FilterDefinition<T> filter, DistinctOptions? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.DistinctAsync(session, field, filter, options, cancellationToken);
+    }
+
+    public long EstimatedDocumentCount(EstimatedDocumentCountOptions? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.EstimatedDocumentCount(options, cancellationToken);
+    }
+
+    public Task<long> EstimatedDocumentCountAsync(EstimatedDocumentCountOptions? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.EstimatedDocumentCountAsync(options, cancellationToken);
+    }
+
+    public Task<IAsyncCursor<TProjection>> FindAsync<TProjection>(FilterDefinition<T> filter, FindOptions<T, TProjection>? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.FindAsync(filter, options, cancellationToken);
+    }
+
+    public Task<IAsyncCursor<TProjection>> FindAsync<TProjection>(IClientSessionHandle session, FilterDefinition<T> filter, FindOptions<T, TProjection>? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.FindAsync(session, filter, options, cancellationToken);
+    }
+
+    public TProjection FindOneAndDelete<TProjection>(FilterDefinition<T> filter, FindOneAndDeleteOptions<T, TProjection>? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.FindOneAndDelete(filter, options, cancellationToken);
+    }
+
+    public TProjection FindOneAndDelete<TProjection>(IClientSessionHandle session, FilterDefinition<T> filter, FindOneAndDeleteOptions<T, TProjection>? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.FindOneAndDelete(session, filter, options, cancellationToken);
+    }
+
+    public Task<TProjection> FindOneAndDeleteAsync<TProjection>(FilterDefinition<T> filter, FindOneAndDeleteOptions<T, TProjection>? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.FindOneAndDeleteAsync(filter, options, cancellationToken);
+    }
+
+    public Task<TProjection> FindOneAndDeleteAsync<TProjection>(IClientSessionHandle session, FilterDefinition<T> filter, FindOneAndDeleteOptions<T, TProjection>? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.FindOneAndDeleteAsync(session, filter, options, cancellationToken);
+    }
+
+    public TProjection FindOneAndReplace<TProjection>(FilterDefinition<T> filter, T replacement, FindOneAndReplaceOptions<T, TProjection>? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.FindOneAndReplace(filter, replacement, options, cancellationToken);
+    }
+
+    public TProjection FindOneAndReplace<TProjection>(IClientSessionHandle session, FilterDefinition<T> filter, T replacement, FindOneAndReplaceOptions<T, TProjection>? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.FindOneAndReplace(session, filter, replacement, options, cancellationToken);
+    }
+
+    public Task<TProjection> FindOneAndReplaceAsync<TProjection>(FilterDefinition<T> filter, T replacement, FindOneAndReplaceOptions<T, TProjection>? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.FindOneAndReplaceAsync(filter, replacement, options, cancellationToken);
+    }
+
+    public Task<TProjection> FindOneAndReplaceAsync<TProjection>(IClientSessionHandle session, FilterDefinition<T> filter, T replacement, FindOneAndReplaceOptions<T, TProjection>? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.FindOneAndReplaceAsync(session, filter, replacement, options, cancellationToken);
+    }
+
+    public TProjection FindOneAndUpdate<TProjection>(FilterDefinition<T> filter, UpdateDefinition<T> update, FindOneAndUpdateOptions<T, TProjection>? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.FindOneAndUpdate(filter, update, options, cancellationToken);
+    }
+
+    public TProjection FindOneAndUpdate<TProjection>(IClientSessionHandle session, FilterDefinition<T> filter, UpdateDefinition<T> update, FindOneAndUpdateOptions<T, TProjection>? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.FindOneAndUpdate(session, filter, update, options, cancellationToken);
+    }
+
+    public Task<TProjection> FindOneAndUpdateAsync<TProjection>(FilterDefinition<T> filter, UpdateDefinition<T> update, FindOneAndUpdateOptions<T, TProjection>? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.FindOneAndUpdateAsync(filter, update, options, cancellationToken);
+    }
+
+    public Task<TProjection> FindOneAndUpdateAsync<TProjection>(IClientSessionHandle session, FilterDefinition<T> filter, UpdateDefinition<T> update, FindOneAndUpdateOptions<T, TProjection>? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.FindOneAndUpdateAsync(session, filter, update, options, cancellationToken);
+    }
+
+    public IAsyncCursor<TProjection> FindSync<TProjection>(FilterDefinition<T> filter, FindOptions<T, TProjection>? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.FindSync(filter, options, cancellationToken);
+    }
+
+    public IAsyncCursor<TProjection> FindSync<TProjection>(IClientSessionHandle session, FilterDefinition<T> filter, FindOptions<T, TProjection>? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.FindSync(session, filter, options, cancellationToken);
+    }
+
+    public void InsertMany(IEnumerable<T> documents, InsertManyOptions? options = null, CancellationToken cancellationToken = default)
+    {
+        Collection.InsertMany(documents, options, cancellationToken);
+    }
+
+    public void InsertMany(IClientSessionHandle session, IEnumerable<T> documents, InsertManyOptions? options = null, CancellationToken cancellationToken = default)
+    {
+        Collection.InsertMany(session, documents, options, cancellationToken);
+    }
+
+    public Task InsertManyAsync(IEnumerable<T> documents, InsertManyOptions? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.InsertManyAsync(documents, options, cancellationToken);
+    }
+
+    public Task InsertManyAsync(IClientSessionHandle session, IEnumerable<T> documents, InsertManyOptions? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.InsertManyAsync(session, documents, options, cancellationToken);
+    }
+
+    public void InsertOne(T document, InsertOneOptions? options = null, CancellationToken cancellationToken = default)
+    {
+        Collection.InsertOne(document, options, cancellationToken);
+    }
+
+    public void InsertOne(IClientSessionHandle session, T document, InsertOneOptions? options = null, CancellationToken cancellationToken = default)
+    {
+        Collection.InsertOne(session, document, options, cancellationToken);
+    }
+
+    [Obsolete("Use the new overload of InsertOneAsync with an InsertOneOptions parameter instead.")]
+    Task IMongoCollection<T>.InsertOneAsync(T document, CancellationToken _cancellationToken)
+    {
+        return Collection.InsertOneAsync(document, _cancellationToken);
+    }
+
+    public Task InsertOneAsync(T document, InsertOneOptions? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.InsertOneAsync(document, options, cancellationToken);
+    }
+
+    public Task InsertOneAsync(IClientSessionHandle session, T document, InsertOneOptions? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.InsertOneAsync(session, document, options, cancellationToken);
+    }
+
+    public IAsyncCursor<TResult> MapReduce<TResult>(BsonJavaScript map, BsonJavaScript reduce, MapReduceOptions<T, TResult>? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.MapReduce(map, reduce, options, cancellationToken);
+    }
+
+    public IAsyncCursor<TResult> MapReduce<TResult>(IClientSessionHandle session, BsonJavaScript map, BsonJavaScript reduce, MapReduceOptions<T, TResult>? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.MapReduce(session, map, reduce, options, cancellationToken);
+    }
+
+    public Task<IAsyncCursor<TResult>> MapReduceAsync<TResult>(BsonJavaScript map, BsonJavaScript reduce, MapReduceOptions<T, TResult>? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.MapReduceAsync(map, reduce, options, cancellationToken);
+    }
+
+    public Task<IAsyncCursor<TResult>> MapReduceAsync<TResult>(IClientSessionHandle session, BsonJavaScript map, BsonJavaScript reduce, MapReduceOptions<T, TResult>? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.MapReduceAsync(session, map, reduce, options, cancellationToken);
+    }
+
+    public IFilteredMongoCollection<TDerivedDocument> OfType<TDerivedDocument>() where TDerivedDocument : T
+    {
+        return Collection.OfType<TDerivedDocument>();
+    }
+
+    public ReplaceOneResult ReplaceOne(FilterDefinition<T> filter, T replacement, ReplaceOptions? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.ReplaceOne(filter, replacement, options, cancellationToken);
+    }
+
+    [Obsolete("Use the overload that takes a ReplaceOptions instead of an UpdateOptions.")]
+    ReplaceOneResult IMongoCollection<T>.ReplaceOne(FilterDefinition<T> filter, T replacement, UpdateOptions options, CancellationToken cancellationToken)
+    {
+        return Collection.ReplaceOne(filter, replacement, options, cancellationToken);
+    }
+
+    public ReplaceOneResult ReplaceOne(IClientSessionHandle session, FilterDefinition<T> filter, T replacement, ReplaceOptions? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.ReplaceOne(session, filter, replacement, options, cancellationToken);
+    }
+
+    [Obsolete("Use the overload that takes a ReplaceOptions instead of an UpdateOptions.")]
+    ReplaceOneResult IMongoCollection<T>.ReplaceOne(IClientSessionHandle session, FilterDefinition<T> filter, T replacement, UpdateOptions options, CancellationToken cancellationToken)
+    {
+        return Collection.ReplaceOne(session, filter, replacement, options, cancellationToken);
+    }
+
+    public Task<ReplaceOneResult> ReplaceOneAsync(FilterDefinition<T> filter, T replacement, ReplaceOptions? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.ReplaceOneAsync(filter, replacement, options, cancellationToken);
+    }
+
+    [Obsolete("Use the overload that takes a ReplaceOptions instead of an UpdateOptions.")]
+    Task<ReplaceOneResult> IMongoCollection<T>.ReplaceOneAsync(FilterDefinition<T> filter, T replacement, UpdateOptions options, CancellationToken cancellationToken)
+    {
+        return Collection.ReplaceOneAsync(filter, replacement, options, cancellationToken);
+    }
+
+    public Task<ReplaceOneResult> ReplaceOneAsync(IClientSessionHandle session, FilterDefinition<T> filter, T replacement, ReplaceOptions? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.ReplaceOneAsync(session, filter, replacement, options, cancellationToken);
+    }
+
+    [Obsolete("Use the overload that takes a ReplaceOptions instead of an UpdateOptions.")]
+    Task<ReplaceOneResult> IMongoCollection<T>.ReplaceOneAsync(IClientSessionHandle session, FilterDefinition<T> filter, T replacement, UpdateOptions options, CancellationToken cancellationToken)
+    {
+        return Collection.ReplaceOneAsync(session, filter, replacement, options, cancellationToken);
+    }
+
+    public UpdateResult UpdateMany(FilterDefinition<T> filter, UpdateDefinition<T> update, UpdateOptions? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.UpdateMany(filter, update, options, cancellationToken);
+    }
+
+    public UpdateResult UpdateMany(IClientSessionHandle session, FilterDefinition<T> filter, UpdateDefinition<T> update, UpdateOptions? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.UpdateMany(session, filter, update, options, cancellationToken);
+    }
+
+    public Task<UpdateResult> UpdateManyAsync(FilterDefinition<T> filter, UpdateDefinition<T> update, UpdateOptions? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.UpdateManyAsync(filter, update, options, cancellationToken);
+    }
+
+    public Task<UpdateResult> UpdateManyAsync(IClientSessionHandle session, FilterDefinition<T> filter, UpdateDefinition<T> update, UpdateOptions? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.UpdateManyAsync(session, filter, update, options, cancellationToken);
+    }
+
+    public UpdateResult UpdateOne(FilterDefinition<T> filter, UpdateDefinition<T> update, UpdateOptions? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.UpdateOne(filter, update, options, cancellationToken);
+    }
+
+    public UpdateResult UpdateOne(IClientSessionHandle session, FilterDefinition<T> filter, UpdateDefinition<T> update, UpdateOptions? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.UpdateOne(session, filter, update, options, cancellationToken);
+    }
+
+    public Task<UpdateResult> UpdateOneAsync(FilterDefinition<T> filter, UpdateDefinition<T> update, UpdateOptions? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.UpdateOneAsync(filter, update, options, cancellationToken);
+    }
+
+    public Task<UpdateResult> UpdateOneAsync(IClientSessionHandle session, FilterDefinition<T> filter, UpdateDefinition<T> update, UpdateOptions? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.UpdateOneAsync(session, filter, update, options, cancellationToken);
+    }
+
+    public IChangeStreamCursor<TResult> Watch<TResult>(PipelineDefinition<ChangeStreamDocument<T>, TResult> pipeline, ChangeStreamOptions? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.Watch(pipeline, options, cancellationToken);
+    }
+
+    public IChangeStreamCursor<TResult> Watch<TResult>(IClientSessionHandle session, PipelineDefinition<ChangeStreamDocument<T>, TResult> pipeline, ChangeStreamOptions? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.Watch(session, pipeline, options, cancellationToken);
+    }
+
+    public Task<IChangeStreamCursor<TResult>> WatchAsync<TResult>(PipelineDefinition<ChangeStreamDocument<T>, TResult> pipeline, ChangeStreamOptions? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.WatchAsync(pipeline, options, cancellationToken);
+    }
+
+    public Task<IChangeStreamCursor<TResult>> WatchAsync<TResult>(IClientSessionHandle session, PipelineDefinition<ChangeStreamDocument<T>, TResult> pipeline, ChangeStreamOptions? options = null, CancellationToken cancellationToken = default)
+    {
+        return Collection.WatchAsync(session, pipeline, options, cancellationToken);
+    }
+
+    public IMongoCollection<T> WithReadConcern(ReadConcern readConcern)
+    {
+        return Collection.WithReadConcern(readConcern);
+    }
+
+    public IMongoCollection<T> WithReadPreference(ReadPreference readPreference)
+    {
+        return Collection.WithReadPreference(readPreference);
+    }
+
+    public IMongoCollection<T> WithWriteConcern(WriteConcern writeConcern)
+    {
+        return Collection.WithWriteConcern(writeConcern);
+    }
+}
diff --git a/MongoDB.Entities/DBCollection/DBCollection.cs b/MongoDB.Entities/DBCollection/DBCollection.cs
new file mode 100644
index 000000000..dd416312a
--- /dev/null
+++ b/MongoDB.Entities/DBCollection/DBCollection.cs
@@ -0,0 +1,24 @@
+using MongoDB.Bson;
+using MongoDB.Bson.Serialization;
+using MongoDB.Driver;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace MongoDB.Entities;
+
+/// <summary>
+/// 
+/// </summary>
+/// <typeparam name="T"></typeparam>
+public partial class DBCollection<T> : IMongoCollection<T>
+{    
+    public IMongoCollection<T> Collection { get; }
+
+    public DBCollection(IMongoCollection<T> collection)
+    {
+        Collection = collection;
+    }
+}
diff --git a/MongoDB.Entities/DBContext/DBContext.Collection.cs b/MongoDB.Entities/DBContext/DBContext.Collection.cs
index e0d632daf..ee05df23f 100644
--- a/MongoDB.Entities/DBContext/DBContext.Collection.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Collection.cs
@@ -4,54 +4,54 @@
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace MongoDB.Entities
+namespace MongoDB.Entities;
+
+public partial class DBContext
 {
-    public partial class DBContext
+    /// <summary>
+    /// Creates a collection for an Entity type explicitly using the given options
+    /// </summary>
+    /// <typeparam name="T">The type of entity that will be stored in the created collection</typeparam>
+    /// <param name="options">The options to use for collection creation</param>
+    /// <param name="cancellation">An optional cancellation token</param>
+    /// <param name="collectionName"></param>
+    public Task CreateCollectionAsync<T>(Action<CreateCollectionOptions<T>> options, CancellationToken cancellation = default, string? collectionName = null) where T : IEntity
     {
-        /// <summary>
-        /// Creates a collection for an Entity type explicitly using the given options
-        /// </summary>
-        /// <typeparam name="T">The type of entity that will be stored in the created collection</typeparam>
-        /// <param name="options">The options to use for collection creation</param>
-        /// <param name="cancellation">An optional cancellation token</param>
-        public Task CreateCollectionAsync<T>(Action<CreateCollectionOptions<T>> options, CancellationToken cancellation = default) where T : IEntity
-        {
-            var opts = new CreateCollectionOptions<T>();
-            options(opts);
-            return Session == null
-                  ? Database.CreateCollectionAsync(Cache<T>().CollectionName, opts, cancellation)
-                  : Database.CreateCollectionAsync(Session, Cache<T>().CollectionName, opts, cancellation);
-        }
+        var opts = new CreateCollectionOptions<T>();
+        options(opts);
+        return Session == null
+              ? Database.CreateCollectionAsync(collectionName ?? CollectionName<T>(), opts, cancellation)
+              : Database.CreateCollectionAsync(Session, collectionName ?? CollectionName<T>(), opts, cancellation);
+    }
 
-        /// <summary>
-        /// Deletes the collection of a given entity type as well as the join collections for that entity.
-        /// <para>TIP: When deleting a collection, all relationships associated with that entity type is also deleted.</para>
-        /// </summary>
-        /// <typeparam name="T">The entity type to drop the collection of</typeparam>
-        public async Task DropCollectionAsync<T>() where T : IEntity
+    /// <summary>
+    /// Deletes the collection of a given entity type as well as the join collections for that entity.
+    /// <para>TIP: When deleting a collection, all relationships associated with that entity type is also deleted.</para>
+    /// </summary>
+    /// <typeparam name="T">The entity type to drop the collection of</typeparam>
+    public async Task DropCollectionAsync<T>(string? collectionName = null) where T : IEntity
+    {
+        var tasks = new List<Task>();
+        var db = Database;
+        var collName = collectionName ?? CollectionName<T>();
+        var options = new ListCollectionNamesOptions
         {
-            var tasks = new List<Task>();
-            var db = Database;
-            var collName = Cache<T>().CollectionName;
-            var options = new ListCollectionNamesOptions
-            {
-                Filter = "{$and:[{name:/~/},{name:/" + collName + "/}]}"
-            };
-
-            foreach (var cName in await db.ListCollectionNames(options).ToListAsync().ConfigureAwait(false))
-            {
-                tasks.Add(
-                    Session == null
-                    ? db.DropCollectionAsync(cName)
-                    : db.DropCollectionAsync(Session, cName));
-            }
+            Filter = "{$and:[{name:/~/},{name:/" + collName + "/}]}"
+        };
 
+        foreach (var cName in await db.ListCollectionNames(options).ToListAsync().ConfigureAwait(false))
+        {
             tasks.Add(
                 Session == null
-                ? db.DropCollectionAsync(collName)
-                : db.DropCollectionAsync(Session, collName));
-
-            await Task.WhenAll(tasks).ConfigureAwait(false);
+                ? db.DropCollectionAsync(cName)
+                : db.DropCollectionAsync(Session, cName));
         }
+
+        tasks.Add(
+            Session == null
+            ? db.DropCollectionAsync(collName)
+            : db.DropCollectionAsync(Session, collName));
+
+        await Task.WhenAll(tasks).ConfigureAwait(false);
     }
 }
diff --git a/MongoDB.Entities/DBContext/DBContext.Count.cs b/MongoDB.Entities/DBContext/DBContext.Count.cs
index e1be5fcbf..76dc3d07f 100644
--- a/MongoDB.Entities/DBContext/DBContext.Count.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Count.cs
@@ -4,73 +4,82 @@
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace MongoDB.Entities
+namespace MongoDB.Entities;
+
+public partial class DBContext
 {
-    public partial class DBContext
+    /// <summary>
+    /// Gets a fast estimation of how many documents are in the collection using metadata.
+    /// <para>HINT: The estimation may not be exactly accurate.</para>
+    /// </summary>
+    /// <typeparam name="T">The entity type to get the count for</typeparam>
+    /// <param name="collectionName">To override the default collection name</param>
+    /// <param name="collection">To override the default collection</param>
+    /// <param name="cancellation">An optional cancellation token</param>
+    public Task<long> CountEstimatedAsync<T>(CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
     {
-        /// <summary>
-        /// Gets a fast estimation of how many documents are in the collection using metadata.
-        /// <para>HINT: The estimation may not be exactly accurate.</para>
-        /// </summary>
-        /// <typeparam name="T">The entity type to get the count for</typeparam>
-        /// <param name="cancellation">An optional cancellation token</param>
-        public Task<long> CountEstimatedAsync<T>(CancellationToken cancellation = default) where T : IEntity
-        {
-            return CollectionFor<T>().EstimatedDocumentCountAsync(cancellationToken: cancellation);
-        }
+        return Collection(collectionName, collection).EstimatedDocumentCountAsync(cancellationToken: cancellation);
+    }
 
-        /// <summary>
-        /// Gets an accurate count of how many entities are matched for a given expression/filter
-        /// </summary>
-        /// <typeparam name="T">The entity type to get the count for</typeparam>
-        /// <param name="expression">A lambda expression for getting the count for a subset of the data</param>
-        /// <param name="cancellation">An optional cancellation token</param>
-        /// <param name="options">An optional CountOptions object</param>
-        /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
-        public Task<long> CountAsync<T>(Expression<Func<T, bool>> expression, CancellationToken cancellation = default, CountOptions? options = null, bool ignoreGlobalFilters = false) where T : IEntity
-        {
-            return CountAsync((FilterDefinition<T>)expression, cancellation, options, ignoreGlobalFilters);
-        }
+    /// <summary>
+    /// Gets an accurate count of how many entities are matched for a given expression/filter
+    /// </summary>
+    /// <typeparam name="T">The entity type to get the count for</typeparam>
+    /// <param name="expression">A lambda expression for getting the count for a subset of the data</param>
+    /// <param name="cancellation">An optional cancellation token</param>
+    /// <param name="options">An optional CountOptions object</param>
+    /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
+    /// <param name="collectionName"></param>
+    /// <param name="collection"></param>
+    public Task<long> CountAsync<T>(Expression<Func<T, bool>> expression, CancellationToken cancellation = default, CountOptions? options = null, bool ignoreGlobalFilters = false, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
+    {
+        return CountAsync((FilterDefinition<T>)expression, cancellation, options, ignoreGlobalFilters, collection: collection, collectionName: collectionName);
+    }
 
-        /// <summary>
-        /// Gets an accurate count of how many total entities are in the collection for a given entity type
-        /// </summary>
-        /// <typeparam name="T">The entity type to get the count for</typeparam>
-        /// <param name="cancellation">An optional cancellation token</param>
-        public Task<long> CountAsync<T>(CancellationToken cancellation = default) where T : IEntity
-        {
-            return CountAsync<T>(_ => true, cancellation);
+    /// <summary>
+    /// Gets an accurate count of how many total entities are in the collection for a given entity type
+    /// </summary>
+    /// <typeparam name="T">The entity type to get the count for</typeparam>
+    /// <param name="cancellation">An optional cancellation token</param>
+    /// <param name="collectionName"></param>
+    /// <param name="collection"></param>
+    public Task<long> CountAsync<T>(CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
+    {
+        return CountAsync<T>(_ => true, cancellation, collectionName: collectionName, collection: collection);
 
-        }
+    }
 
-        /// <summary>
-        /// Gets an accurate count of how many total entities are in the collection for a given entity type
-        /// </summary>
-        /// <typeparam name="T">The entity type to get the count for</typeparam>
-        /// <param name="filter">A filter definition</param>
-        /// <param name="cancellation">An optional cancellation token</param>
-        /// <param name="options">An optional CountOptions object</param>
-        /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
-        public Task<long> CountAsync<T>(FilterDefinition<T> filter, CancellationToken cancellation = default, CountOptions? options = null, bool ignoreGlobalFilters = false) where T : IEntity
-        {
-            filter = Logic.MergeWithGlobalFilter(ignoreGlobalFilters, _globalFilters, filter);
-            return
-                 Session == null
-                 ? CollectionFor<T>().CountDocumentsAsync(filter, options, cancellation)
-                 : CollectionFor<T>().CountDocumentsAsync(Session, filter, options, cancellation);
-        }
+    /// <summary>
+    /// Gets an accurate count of how many total entities are in the collection for a given entity type
+    /// </summary>
+    /// <typeparam name="T">The entity type to get the count for</typeparam>
+    /// <param name="filter">A filter definition</param>
+    /// <param name="cancellation">An optional cancellation token</param>
+    /// <param name="options">An optional CountOptions object</param>
+    /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
+    /// <param name="collectionName"></param>
+    /// <param name="collection"></param>
+    public Task<long> CountAsync<T>(FilterDefinition<T> filter, CancellationToken cancellation = default, CountOptions? options = null, bool ignoreGlobalFilters = false, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
+    {
+        filter = Logic.MergeWithGlobalFilter(ignoreGlobalFilters, _globalFilters, filter);
+        return
+             Session == null
+             ? Collection(collectionName, collection).CountDocumentsAsync(filter, options, cancellation)
+             : Collection(collectionName, collection).CountDocumentsAsync(Session, filter, options, cancellation);
+    }
 
-        /// <summary>
-        /// Gets an accurate count of how many total entities are in the collection for a given entity type
-        /// </summary>
-        /// <typeparam name="T">The entity type to get the count for</typeparam>
-        /// <param name="filter">f => f.Eq(x => x.Prop, Value) &amp; f.Gt(x => x.Prop, Value)</param>
-        /// <param name="cancellation">An optional cancellation token</param>
-        /// <param name="options">An optional CountOptions object</param>
-        /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
-        public Task<long> CountAsync<T>(Func<FilterDefinitionBuilder<T>, FilterDefinition<T>> filter, CancellationToken cancellation = default, CountOptions? options = null, bool ignoreGlobalFilters = false) where T : IEntity
-        {
-            return CountAsync(filter(Builders<T>.Filter), cancellation, options, ignoreGlobalFilters);
-        }
+    /// <summary>
+    /// Gets an accurate count of how many total entities are in the collection for a given entity type
+    /// </summary>
+    /// <typeparam name="T">The entity type to get the count for</typeparam>
+    /// <param name="filter">f => f.Eq(x => x.Prop, Value) &amp; f.Gt(x => x.Prop, Value)</param>
+    /// <param name="cancellation">An optional cancellation token</param>
+    /// <param name="options">An optional CountOptions object</param>
+    /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
+    /// <param name="collectionName"></param>
+    /// <param name="collection"></param>
+    public Task<long> CountAsync<T>(Func<FilterDefinitionBuilder<T>, FilterDefinition<T>> filter, CancellationToken cancellation = default, CountOptions? options = null, bool ignoreGlobalFilters = false, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
+    {
+        return CountAsync(filter(Builders<T>.Filter), cancellation, options, ignoreGlobalFilters, collectionName: collectionName, collection: collection);
     }
 }
diff --git a/MongoDB.Entities/DBContext/DBContext.Delete.cs b/MongoDB.Entities/DBContext/DBContext.Delete.cs
index b8800ebf6..b1ea05eb5 100644
--- a/MongoDB.Entities/DBContext/DBContext.Delete.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Delete.cs
@@ -6,164 +6,172 @@
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace MongoDB.Entities
+namespace MongoDB.Entities;
+
+public partial class DBContext
 {
-    public partial class DBContext
+    private static readonly int _deleteBatchSize = 100000;
+    private void ThrowIfCancellationNotSupported(CancellationToken cancellation = default)
     {
-        private static readonly int _deleteBatchSize = 100000;
-        private void ThrowIfCancellationNotSupported(CancellationToken cancellation = default)
-        {
-            if (cancellation != default && Session is null)
-                throw new NotSupportedException("Cancellation is only supported within transactions for delete operations!");
-        }
+        if (cancellation != default && Session is null)
+            throw new NotSupportedException("Cancellation is only supported within transactions for delete operations!");
+    }
 
-        private async Task<DeleteResult> DeleteCascadingAsync<T>(IEnumerable<string> IDs, CancellationToken cancellation = default) where T : IEntity
-        {
-            // note: cancellation should not be enabled outside of transactions because multiple collections are involved 
-            //       and premature cancellation could cause data inconsistencies.
-            //       i.e. don't pass the cancellation token to delete methods below that don't take a session.
-            //       also make consumers call ThrowIfCancellationNotSupported() before calling this method.
+    private async Task<DeleteResult> DeleteCascadingAsync<T>(IEnumerable<string> IDs, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
+    {
+        // note: cancellation should not be enabled outside of transactions because multiple collections are involved 
+        //       and premature cancellation could cause data inconsistencies.
+        //       i.e. don't pass the cancellation token to delete methods below that don't take a session.
+        //       also make consumers call ThrowIfCancellationNotSupported() before calling this method.
 
-            var db = Database;
-            var options = new ListCollectionNamesOptions
-            {
-                Filter = "{$and:[{name:/~/},{name:/" + Cache<T>().CollectionName + "/}]}"
-            };
+        var options = new ListCollectionNamesOptions
+        {
+            Filter = "{$and:[{name:/~/},{name:/" + collectionName ?? Cache<T>().CollectionName + "/}]}"
+        };
 
-            var tasks = new List<Task>();
+        var tasks = new List<Task>();
 
-            // note: db.listCollections() mongo command does not support transactions.
-            //       so don't add session support here.
-            var collNamesCursor = await db.ListCollectionNamesAsync(options, cancellation).ConfigureAwait(false);
+        // note: db.listCollections() mongo command does not support transactions.
+        //       so don't add session support here.
+        var collNamesCursor = await ListCollectionNamesAsync(options, cancellation).ConfigureAwait(false);
 
-            foreach (var cName in await collNamesCursor.ToListAsync(cancellation).ConfigureAwait(false))
-            {
-                tasks.Add(
-                    Session is null
-                    ? db.GetCollection<JoinRecord>(cName).DeleteManyAsync(r => IDs.Contains(r.ChildID) || IDs.Contains(r.ParentID))
-                    : db.GetCollection<JoinRecord>(cName).DeleteManyAsync(Session, r => IDs.Contains(r.ChildID) || IDs.Contains(r.ParentID), null, cancellation));
-            }
+        foreach (var cName in await collNamesCursor.ToListAsync(cancellation).ConfigureAwait(false))
+        {
+            tasks.Add(
+                Session is null
+                ? Collection<JoinRecord>(cName).DeleteManyAsync(r => IDs.Contains(r.ChildID) || IDs.Contains(r.ParentID))
+                : Collection<JoinRecord>(cName).DeleteManyAsync(Session, r => IDs.Contains(r.ChildID) || IDs.Contains(r.ParentID), null, cancellation));
+        }
 
-            var delResTask =
-                    Session == null
-                    ? CollectionFor<T>().DeleteManyAsync(x => IDs.Contains(x.ID))
-                    : CollectionFor<T>().DeleteManyAsync(Session, x => IDs.Contains(x.ID), null, cancellation);
+        var delResTask =
+                Session == null
+                ? Collection(collectionName, collection).DeleteManyAsync(x => IDs.Contains(x.ID))
+                : Collection(collectionName, collection).DeleteManyAsync(Session, x => IDs.Contains(x.ID), null, cancellation);
 
-            tasks.Add(delResTask);
+        tasks.Add(delResTask);
 
-            if (typeof(T).BaseType == typeof(FileEntity))
-            {
-                tasks.Add(
-                    Session is null
-                    ? db.GetCollection<FileChunk>(Cache<FileChunk>().CollectionName).DeleteManyAsync(x => IDs.Contains(x.FileID))
-                    : db.GetCollection<FileChunk>(Cache<FileChunk>().CollectionName).DeleteManyAsync(Session, x => IDs.Contains(x.FileID), null, cancellation));
-            }
+        if (typeof(FileEntity).IsAssignableFrom(typeof(T)))
+        {
+            tasks.Add(
+                Session is null
+                ? Collection<FileChunk>().DeleteManyAsync(x => IDs.Contains(x.FileID))
+                : Collection<FileChunk>().DeleteManyAsync(Session, x => IDs.Contains(x.FileID), null, cancellation));
+        }
 
-            await Task.WhenAll(tasks).ConfigureAwait(false);
+        await Task.WhenAll(tasks).ConfigureAwait(false);
 
-            return await delResTask.ConfigureAwait(false);
-        }
+        return await delResTask.ConfigureAwait(false);
+    }
 
 
-        /// <summary>
-        /// Deletes a single entity from MongoDB
-        /// <para>HINT: If this entity is referenced by one-to-many/many-to-many relationships, those references are also deleted.</para>
-        /// </summary>
-        /// <typeparam name="T">The type of entity</typeparam>
-        /// <param name="ID">The Id of the entity to delete</param>
-        /// <param name="cancellation">An optional cancellation token</param>
-        /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
-        public Task<DeleteResult> DeleteAsync<T>(string ID, CancellationToken cancellation = default, bool ignoreGlobalFilters = false) where T : IEntity
-        {
-            return DeleteAsync(Builders<T>.Filter.Eq(e => e.ID, ID), cancellation, ignoreGlobalFilters: ignoreGlobalFilters);
-        }
+    /// <summary>
+    /// Deletes a single entity from MongoDB
+    /// <para>HINT: If this entity is referenced by one-to-many/many-to-many relationships, those references are also deleted.</para>
+    /// </summary>
+    /// <typeparam name="T">The type of entity</typeparam>
+    /// <param name="ID">The Id of the entity to delete</param>
+    /// <param name="cancellation">An optional cancellation token</param>
+    /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
+    /// <param name="collectionName"></param>
+    /// <param name="collection"></param>
+    public Task<DeleteResult> DeleteAsync<T>(string ID, CancellationToken cancellation = default, bool ignoreGlobalFilters = false, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
+    {
+        return DeleteAsync(Builders<T>.Filter.Eq(e => e.ID, ID), cancellation, ignoreGlobalFilters: ignoreGlobalFilters, collection: collection, collectionName: collectionName);
+    }
 
-        /// <summary>
-        /// Deletes matching entities from MongoDB
-        /// <para>HINT: If these entities are referenced by one-to-many/many-to-many relationships, those references are also deleted.</para>
-        /// <para>TIP: Try to keep the number of entities to delete under 100 in a single call</para>
-        /// </summary>
-        /// <typeparam name="T">The type of entity</typeparam>
-        /// <param name="IDs">An IEnumerable of entity IDs</param>
-        /// <param name="cancellation">An optional cancellation token</param>
-        /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
-        public Task<DeleteResult> DeleteAsync<T>(IEnumerable<string> IDs, CancellationToken cancellation = default, bool ignoreGlobalFilters = false) where T : IEntity
-        {
-            return DeleteAsync(Builders<T>.Filter.In(e => e.ID, IDs), cancellation, ignoreGlobalFilters: ignoreGlobalFilters);
-        }
+    /// <summary>
+    /// Deletes matching entities from MongoDB
+    /// <para>HINT: If these entities are referenced by one-to-many/many-to-many relationships, those references are also deleted.</para>
+    /// <para>TIP: Try to keep the number of entities to delete under 100 in a single call</para>
+    /// </summary>
+    /// <typeparam name="T">The type of entity</typeparam>
+    /// <param name="IDs">An IEnumerable of entity IDs</param>
+    /// <param name="cancellation">An optional cancellation token</param>
+    /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
+    /// <param name="collectionName"></param>
+    /// <param name="collection"></param>
+    public Task<DeleteResult> DeleteAsync<T>(IEnumerable<string> IDs, CancellationToken cancellation = default, bool ignoreGlobalFilters = false, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
+    {
+        return DeleteAsync(Builders<T>.Filter.In(e => e.ID, IDs), cancellation, ignoreGlobalFilters: ignoreGlobalFilters, collection: collection, collectionName: collectionName);
+    }
 
-        /// <summary>
-        /// Deletes matching entities from MongoDB
-        /// <para>HINT: If these entities are referenced by one-to-many/many-to-many relationships, those references are also deleted.</para>
-        /// <para>TIP: Try to keep the number of entities to delete under 100 in a single call</para>
-        /// </summary>
-        /// <typeparam name="T">The type of entity</typeparam>
-        /// <param name="expression">A lambda expression for matching entities to delete.</param>
-        /// <param name="cancellation">An optional cancellation token</param>
-        /// <param name="collation">An optional collation object</param>
-        /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
-        public Task<DeleteResult> DeleteAsync<T>(Expression<Func<T, bool>> expression, CancellationToken cancellation = default, Collation? collation = null, bool ignoreGlobalFilters = false) where T : IEntity
-        {
-            return DeleteAsync(Builders<T>.Filter.Where(expression), cancellation, collation, ignoreGlobalFilters);
-        }
+    /// <summary>
+    /// Deletes matching entities from MongoDB
+    /// <para>HINT: If these entities are referenced by one-to-many/many-to-many relationships, those references are also deleted.</para>
+    /// <para>TIP: Try to keep the number of entities to delete under 100 in a single call</para>
+    /// </summary>
+    /// <typeparam name="T">The type of entity</typeparam>
+    /// <param name="expression">A lambda expression for matching entities to delete.</param>
+    /// <param name="cancellation">An optional cancellation token</param>
+    /// <param name="collation">An optional collation object</param>
+    /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
+    /// <param name="collectionName"></param>
+    /// <param name="collection"></param>
+    public Task<DeleteResult> DeleteAsync<T>(Expression<Func<T, bool>> expression, CancellationToken cancellation = default, Collation? collation = null, bool ignoreGlobalFilters = false, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
+    {
+        return DeleteAsync(Builders<T>.Filter.Where(expression), cancellation, collation, ignoreGlobalFilters, collection: collection, collectionName: collectionName);
+    }
 
-        /// <summary>
-        /// Deletes matching entities with a filter expression
-        /// <para>HINT: If the expression matches more than 100,000 entities, they will be deleted in batches of 100k.</para>
-        /// <para>HINT: If these entities are referenced by one-to-many/many-to-many relationships, those references are also deleted.</para>
-        /// </summary>
-        /// <typeparam name="T">Any class that implements IEntity</typeparam>
-        /// <param name="filter">f => f.Eq(x => x.Prop, Value) &amp; f.Gt(x => x.Prop, Value)</param>
-        /// <param name="cancellation">An optional cancellation token</param>
-        /// <param name="collation">An optional collation object</param>
-        /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
-        public Task<DeleteResult> DeleteAsync<T>(Func<FilterDefinitionBuilder<T>, FilterDefinition<T>> filter, CancellationToken cancellation = default, Collation? collation = null, bool ignoreGlobalFilters = false) where T : IEntity
-        {
-            return DeleteAsync(filter(Builders<T>.Filter), cancellation, collation, ignoreGlobalFilters);
-        }
+    /// <summary>
+    /// Deletes matching entities with a filter expression
+    /// <para>HINT: If the expression matches more than 100,000 entities, they will be deleted in batches of 100k.</para>
+    /// <para>HINT: If these entities are referenced by one-to-many/many-to-many relationships, those references are also deleted.</para>
+    /// </summary>
+    /// <typeparam name="T">Any class that implements IEntity</typeparam>
+    /// <param name="filter">f => f.Eq(x => x.Prop, Value) &amp; f.Gt(x => x.Prop, Value)</param>
+    /// <param name="cancellation">An optional cancellation token</param>
+    /// <param name="collation">An optional collation object</param>
+    /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
+    /// <param name="collectionName"></param>
+    /// <param name="collection"></param>
+    public Task<DeleteResult> DeleteAsync<T>(Func<FilterDefinitionBuilder<T>, FilterDefinition<T>> filter, CancellationToken cancellation = default, Collation? collation = null, bool ignoreGlobalFilters = false, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
+    {
+        return DeleteAsync(filter(Builders<T>.Filter), cancellation, collation, ignoreGlobalFilters, collection: collection, collectionName: collectionName);
+    }
 
-        /// <summary>
-        /// Deletes matching entities with a filter definition
-        /// <para>HINT: If the expression matches more than 100,000 entities, they will be deleted in batches of 100k.</para>
-        /// <para>HINT: If these entities are referenced by one-to-many/many-to-many relationships, those references are also deleted.</para>
-        /// </summary>
-        /// <typeparam name="T">Any class that implements IEntity</typeparam>
-        /// <param name="filter">A filter definition for matching entities to delete.</param>
-        /// <param name="cancellation">An optional cancellation token</param>
-        /// <param name="collation">An optional collation object</param>
-        /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
-        public async Task<DeleteResult> DeleteAsync<T>(FilterDefinition<T> filter, CancellationToken cancellation = default, Collation? collation = null, bool ignoreGlobalFilters = false) where T : IEntity
-        {
-            ThrowIfCancellationNotSupported(cancellation);
+    /// <summary>
+    /// Deletes matching entities with a filter definition
+    /// <para>HINT: If the expression matches more than 100,000 entities, they will be deleted in batches of 100k.</para>
+    /// <para>HINT: If these entities are referenced by one-to-many/many-to-many relationships, those references are also deleted.</para>
+    /// </summary>
+    /// <typeparam name="T">Any class that implements IEntity</typeparam>
+    /// <param name="filter">A filter definition for matching entities to delete.</param>
+    /// <param name="cancellation">An optional cancellation token</param>
+    /// <param name="collation">An optional collation object</param>
+    /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
+    /// <param name="collectionName"></param>
+    /// <param name="collection"></param>
+    public async Task<DeleteResult> DeleteAsync<T>(FilterDefinition<T> filter, CancellationToken cancellation = default, Collation? collation = null, bool ignoreGlobalFilters = false, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
+    {
+        ThrowIfCancellationNotSupported(cancellation);
 
-            var filterDef = Logic.MergeWithGlobalFilter(ignoreGlobalFilters, _globalFilters, filter);
-            var cursor = await new Find<T, string>(this, CollectionFor<T>())
-                               .Match(filter)
-                               .Project(e => e.ID)
-                               .Option(o => o.BatchSize = _deleteBatchSize)
-                               .Option(o => o.Collation = collation)
-                               .ExecuteCursorAsync(cancellation)
-                               .ConfigureAwait(false);
+        var filterDef = Logic.MergeWithGlobalFilter(ignoreGlobalFilters, _globalFilters, filter);
+        var cursor = await new Find<T, string>(this, Collection(collectionName, collection))
+                           .Match(filter)
+                           .Project(e => e.ID)
+                           .Option(o => o.BatchSize = _deleteBatchSize)
+                           .Option(o => o.Collation = collation)
+                           .ExecuteCursorAsync(cancellation)
+                           .ConfigureAwait(false);
 
-            long deletedCount = 0;
-            DeleteResult? res = null;
+        long deletedCount = 0;
+        DeleteResult? res = null;
 
-            using (cursor)
+        using (cursor)
+        {
+            while (await cursor.MoveNextAsync(cancellation).ConfigureAwait(false))
             {
-                while (await cursor.MoveNextAsync(cancellation).ConfigureAwait(false))
+                if (cursor.Current.Any())
                 {
-                    if (cursor.Current.Any())
-                    {
-                        res = await DeleteCascadingAsync<T>(cursor.Current, cancellation).ConfigureAwait(false);
-                        deletedCount += res.DeletedCount;
-                    }
+                    res = await DeleteCascadingAsync<T>(cursor.Current, cancellation).ConfigureAwait(false);
+                    deletedCount += res.DeletedCount;
                 }
             }
+        }
 
-            if (res?.IsAcknowledged == false)
-                return DeleteResult.Unacknowledged.Instance;
+        if (res?.IsAcknowledged == false)
+            return DeleteResult.Unacknowledged.Instance;
 
-            return new DeleteResult.Acknowledged(deletedCount);
-        }
+        return new DeleteResult.Acknowledged(deletedCount);
     }
 }
diff --git a/MongoDB.Entities/DBContext/DBContext.Distinct.cs b/MongoDB.Entities/DBContext/DBContext.Distinct.cs
index 3beaa8437..52b65b5b5 100644
--- a/MongoDB.Entities/DBContext/DBContext.Distinct.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Distinct.cs
@@ -1,15 +1,16 @@
-namespace MongoDB.Entities
+using MongoDB.Driver;
+
+namespace MongoDB.Entities;
+
+public partial class DBContext
 {
-    public partial class DBContext
+    /// <summary>
+    /// Represents a MongoDB Distinct command where you can get back distinct values for a given property of a given Entity
+    /// </summary>
+    /// <typeparam name="T">Any Entity that implements IEntity interface</typeparam>
+    /// <typeparam name="TProperty">The type of the property of the entity you'd like to get unique values for</typeparam>
+    public Distinct<T, TProperty> Distinct<T, TProperty>(string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
     {
-        /// <summary>
-        /// Represents a MongoDB Distinct command where you can get back distinct values for a given property of a given Entity
-        /// </summary>
-        /// <typeparam name="T">Any Entity that implements IEntity interface</typeparam>
-        /// <typeparam name="TProperty">The type of the property of the entity you'd like to get unique values for</typeparam>
-        public Distinct<T, TProperty> Distinct<T, TProperty>() where T : IEntity
-        {
-            return new Distinct<T, TProperty>(this, CollectionFor<T>());
-        }
+        return new Distinct<T, TProperty>(this, Collection(collectionName, collection));
     }
 }
diff --git a/MongoDB.Entities/DBContext/DBContext.File.cs b/MongoDB.Entities/DBContext/DBContext.File.cs
index 8826cc358..0c0c38598 100644
--- a/MongoDB.Entities/DBContext/DBContext.File.cs
+++ b/MongoDB.Entities/DBContext/DBContext.File.cs
@@ -1,21 +1,23 @@
 using MongoDB.Bson;
+using MongoDB.Driver;
 using System;
 
-namespace MongoDB.Entities
+namespace MongoDB.Entities;
+
+public partial class DBContext
 {
-    public partial class DBContext
+    /// <summary>
+    /// Returns a DataStreamer object to enable uploading/downloading file data directly by supplying the ID of the file entity
+    /// </summary>
+    /// <typeparam name="T">The file entity type</typeparam>
+    /// <param name="ID">The ID of the file entity</param>
+    /// <param name="collectionName"></param>
+    /// <param name="collection"></param>
+    public DataStreamer<T> File<T>(string ID, string? collectionName = null, IMongoCollection<T>? collection = null) where T : FileEntity, new()
     {
-        /// <summary>
-        /// Returns a DataStreamer object to enable uploading/downloading file data directly by supplying the ID of the file entity
-        /// </summary>
-        /// <typeparam name="T">The file entity type</typeparam>
-        /// <param name="ID">The ID of the file entity</param>
-        public DataStreamer<T> File<T>(string ID) where T : FileEntity, new()
-        {
-            if (!ObjectId.TryParse(ID, out _))
-                throw new ArgumentException("The ID passed in is not of the correct format!");
+        if (!ObjectId.TryParse(ID, out _))
+            throw new ArgumentException("The ID passed in is not of the correct format!");
 
-            return new DataStreamer<T>(new T() { ID = ID, UploadSuccessful = true }, this);
-        }
+        return new DataStreamer<T>(new T() { ID = ID, UploadSuccessful = true }, this, Collection<T>(collectionName, collection));
     }
 }
diff --git a/MongoDB.Entities/DBContext/DBContext.Find.cs b/MongoDB.Entities/DBContext/DBContext.Find.cs
index 194f6cda9..85d10b264 100644
--- a/MongoDB.Entities/DBContext/DBContext.Find.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Find.cs
@@ -1,24 +1,25 @@
-namespace MongoDB.Entities
+using MongoDB.Driver;
+
+namespace MongoDB.Entities;
+
+public partial class DBContext
 {
-    public partial class DBContext
+    /// <summary>
+    /// Starts a find command for the given entity type
+    /// </summary>
+    /// <typeparam name="T">The type of entity</typeparam>
+    public Find<T> Find<T>(string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
     {
-        /// <summary>
-        /// Starts a find command for the given entity type
-        /// </summary>
-        /// <typeparam name="T">The type of entity</typeparam>
-        public Find<T> Find<T>() where T : IEntity
-        {
-            return new Find<T>(this, CollectionFor<T>());
-        }
+        return new Find<T>(this, Collection(collectionName, collection));
+    }
 
-        /// <summary>
-        /// Starts a find command with projection support for the given entity type
-        /// </summary>
-        /// <typeparam name="T">The type of entity</typeparam>
-        /// <typeparam name="TProjection">The type of the end result</typeparam>
-        public Find<T, TProjection> Find<T, TProjection>() where T : IEntity
-        {
-            return new Find<T, TProjection>(this, CollectionFor<T>());
-        }
+    /// <summary>
+    /// Starts a find command with projection support for the given entity type
+    /// </summary>
+    /// <typeparam name="T">The type of entity</typeparam>
+    /// <typeparam name="TProjection">The type of the end result</typeparam>
+    public Find<T, TProjection> Find<T, TProjection>(string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
+    {
+        return new Find<T, TProjection>(this, Collection(collectionName, collection));
     }
 }
diff --git a/MongoDB.Entities/DBContext/DBContext.Fluent.cs b/MongoDB.Entities/DBContext/DBContext.Fluent.cs
index 649036c52..d6f3f05cf 100644
--- a/MongoDB.Entities/DBContext/DBContext.Fluent.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Fluent.cs
@@ -10,13 +10,15 @@ public partial class DBContext
         /// <typeparam name="T">The type of entity</typeparam>
         /// <param name="options">The options for the aggregation. This is not required.</param>
         /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
-        public IAggregateFluent<T> Fluent<T>(AggregateOptions? options = null, bool ignoreGlobalFilters = false) where T : IEntity
+        /// <param name="collectionName"></param>
+        /// <param name="collection"></param>
+        public IAggregateFluent<T> Fluent<T>(AggregateOptions? options = null, bool ignoreGlobalFilters = false, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
         {
             var globalFilter = Logic.MergeWithGlobalFilter(ignoreGlobalFilters, _globalFilters, Builders<T>.Filter.Empty);
 
             var aggregate = Session is not IClientSessionHandle session
-                   ? CollectionFor<T>().Aggregate(options)
-                   : CollectionFor<T>().Aggregate(session, options);
+                   ? Collection(collectionName, collection).Aggregate(options)
+                   : Collection(collectionName, collection).Aggregate(session, options);
 
             if (globalFilter != Builders<T>.Filter.Empty)
             {
@@ -36,7 +38,9 @@ public IAggregateFluent<T> Fluent<T>(AggregateOptions? options = null, bool igno
         /// <param name="language">The language for the search (optional)</param>
         /// <param name="options">Options for finding documents (not required)</param>
         /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
-        public IAggregateFluent<T> FluentTextSearch<T>(Search searchType, string searchTerm, bool caseSensitive = false, bool diacriticSensitive = false, string? language = null, AggregateOptions? options = null, bool ignoreGlobalFilters = false) where T : IEntity
+        /// <param name="collectionName"></param>
+        /// <param name="collection"></param>
+        public IAggregateFluent<T> FluentTextSearch<T>(Search searchType, string searchTerm, bool caseSensitive = false, bool diacriticSensitive = false, string? language = null, AggregateOptions? options = null, bool ignoreGlobalFilters = false, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
         {
             var globalFilter = Logic.MergeWithGlobalFilter(ignoreGlobalFilters, _globalFilters, Builders<T>.Filter.Empty);
 
@@ -58,8 +62,8 @@ public IAggregateFluent<T> FluentTextSearch<T>(Search searchType, string searchT
                             });
 
             var aggregate = Session is not IClientSessionHandle session
-                   ? CollectionFor<T>().Aggregate(options).Match(filter)
-                   : CollectionFor<T>().Aggregate(session, options).Match(filter);
+                   ? Collection(collectionName, collection).Aggregate(options).Match(filter)
+                   : Collection(collectionName, collection).Aggregate(session, options).Match(filter);
 
 
             if (globalFilter != Builders<T>.Filter.Empty)
diff --git a/MongoDB.Entities/DBContext/DBContext.GeoNear.cs b/MongoDB.Entities/DBContext/DBContext.GeoNear.cs
index 8e9238d6f..bc1274aa9 100644
--- a/MongoDB.Entities/DBContext/DBContext.GeoNear.cs
+++ b/MongoDB.Entities/DBContext/DBContext.GeoNear.cs
@@ -23,7 +23,9 @@ public partial class DBContext
         /// <param name="options">The options for the aggregation. This is not required.</param>
         /// <typeparam name="T">The type of entity</typeparam>
         /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
-        public IAggregateFluent<T> GeoNear<T>(Coordinates2D NearCoordinates, Expression<Func<T, object>>? DistanceField, bool Spherical = true, double? MaxDistance = null, double? MinDistance = null, int? Limit = null, BsonDocument? Query = null, double? DistanceMultiplier = null, Expression<Func<T, object>>? IncludeLocations = null, string? IndexKey = null, AggregateOptions? options = null, bool ignoreGlobalFilters = false) where T : IEntity
+        /// <param name="collectionName"></param>
+        /// <param name="collection"></param>
+        public IAggregateFluent<T> GeoNear<T>(Coordinates2D NearCoordinates, Expression<Func<T, object>>? DistanceField, bool Spherical = true, double? MaxDistance = null, double? MinDistance = null, int? Limit = null, BsonDocument? Query = null, double? DistanceMultiplier = null, Expression<Func<T, object>>? IncludeLocations = null, string? IndexKey = null, AggregateOptions? options = null, bool ignoreGlobalFilters = false, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
         {
             var globalFilter = Logic.MergeWithGlobalFilter(ignoreGlobalFilters, _globalFilters, Builders<T>.Filter.Empty);
 
@@ -40,7 +42,7 @@ public IAggregateFluent<T> GeoNear<T>(Coordinates2D NearCoordinates, Expression<
                 includeLocs = IncludeLocations?.FullPath(),
                 key = IndexKey,
             }
-            .ToFluent(this, options);
+            .ToFluent(this, options, collectionName: collectionName, collection: collection);
 
             if (globalFilter != Builders<T>.Filter.Empty)
             {
diff --git a/MongoDB.Entities/DBContext/DBContext.IMongoDatabase.cs b/MongoDB.Entities/DBContext/DBContext.IMongoDatabase.cs
index 73a2cdbea..20663f796 100644
--- a/MongoDB.Entities/DBContext/DBContext.IMongoDatabase.cs
+++ b/MongoDB.Entities/DBContext/DBContext.IMongoDatabase.cs
@@ -111,7 +111,11 @@ public Task DropCollectionAsync(IClientSessionHandle session, string name, Cance
             return Database.DropCollectionAsync(session, name, cancellationToken);
         }
 
-        public IMongoCollection<TDocument> GetCollection<TDocument>(string name, MongoCollectionSettings? settings = null)
+        public DBCollection<TDocument> GetCollection<TDocument>(string name, MongoCollectionSettings? settings = null)
+        {
+            return new(Database.GetCollection<TDocument>(name, settings));
+        }
+        IMongoCollection<TDocument> IMongoDatabase.GetCollection<TDocument>(string name, MongoCollectionSettings? settings)
         {
             return Database.GetCollection<TDocument>(name, settings);
         }
@@ -126,12 +130,12 @@ IAsyncCursor<string> IMongoDatabase.ListCollectionNames(IClientSessionHandle ses
             return Database.ListCollectionNames(session, options, cancellationToken);
         }
 
-        Task<IAsyncCursor<string>> IMongoDatabase.ListCollectionNamesAsync(ListCollectionNamesOptions options, CancellationToken cancellationToken)
+        public Task<IAsyncCursor<string>> ListCollectionNamesAsync(ListCollectionNamesOptions options, CancellationToken cancellationToken)
         {
             return Database.ListCollectionNamesAsync(options, cancellationToken);
         }
 
-        Task<IAsyncCursor<string>> IMongoDatabase.ListCollectionNamesAsync(IClientSessionHandle session, ListCollectionNamesOptions options, CancellationToken cancellationToken)
+        public Task<IAsyncCursor<string>> ListCollectionNamesAsync(IClientSessionHandle session, ListCollectionNamesOptions options, CancellationToken cancellationToken)
         {
             return Database.ListCollectionNamesAsync(session, options, cancellationToken);
         }
diff --git a/MongoDB.Entities/DBContext/DBContext.Index.cs b/MongoDB.Entities/DBContext/DBContext.Index.cs
index 9898d7cdd..8f500cd67 100644
--- a/MongoDB.Entities/DBContext/DBContext.Index.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Index.cs
@@ -1,4 +1,6 @@
-namespace MongoDB.Entities
+using MongoDB.Driver;
+
+namespace MongoDB.Entities
 {
     public partial class DBContext
     {
@@ -7,9 +9,9 @@ public partial class DBContext
         /// <para>TIP: Define the keys first with .Key() method and finally call the .Create() method.</para>
         /// </summary>
         /// <typeparam name="T">Any class that implements IEntity</typeparam>
-        public Index<T> Index<T>() where T : IEntity
+        public Index<T> Index<T>(string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
         {
-            return new Index<T>(this, CollectionFor<T>());
+            return new Index<T>(this, Collection(collectionName, collection));
         }
     }
 }
diff --git a/MongoDB.Entities/DBContext/DBContext.Insert.cs b/MongoDB.Entities/DBContext/DBContext.Insert.cs
index da90c4884..4e66f8163 100644
--- a/MongoDB.Entities/DBContext/DBContext.Insert.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Insert.cs
@@ -1,5 +1,8 @@
 using MongoDB.Driver;
+using System;
 using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -7,6 +10,47 @@ namespace MongoDB.Entities
 {
     public partial class DBContext
     {
+        private static readonly BulkWriteOptions _unOrdBlkOpts = new() { IsOrdered = false };
+        private static readonly UpdateOptions _updateOptions = new() { IsUpsert = true };
+        private Task<UpdateResult> SavePartial<T>(T entity, Expression<Func<T, object>> members, CancellationToken cancellation, bool excludeMode = false, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
+        {
+            PrepAndCheckIfInsert(entity); //just prep. we don't care about inserts here
+            return
+                Session == null
+                ? Collection(collectionName, collection).UpdateOneAsync(e => e.ID == entity.ID, Builders<T>.Update.Combine(Logic.BuildUpdateDefs(entity, members, excludeMode)), _updateOptions, cancellation)
+                : Collection(collectionName, collection).UpdateOneAsync(Session, e => e.ID == entity.ID, Builders<T>.Update.Combine(Logic.BuildUpdateDefs(entity, members, excludeMode)), _updateOptions, cancellation);
+        }
+
+        private Task<BulkWriteResult<T>> SavePartial<T>(IEnumerable<T> entities, Expression<Func<T, object>> members, CancellationToken cancellation, bool excludeMode = false, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
+        {
+            var models = entities.Select(ent =>
+            {
+                PrepAndCheckIfInsert(ent); //just prep. we don't care about inserts here
+                return new UpdateOneModel<T>(
+                            filter: Builders<T>.Filter.Eq(e => e.ID, ent.ID),
+                            update: Builders<T>.Update.Combine(Logic.BuildUpdateDefs(ent, members, excludeMode)))
+                { IsUpsert = true };
+            }).ToList();
+            return Session == null
+                ? Collection(collectionName, collection).BulkWriteAsync(models, _unOrdBlkOpts, cancellation)
+                : Collection(collectionName, collection).BulkWriteAsync(Session, models, _unOrdBlkOpts, cancellation);
+        }
+
+        private bool PrepAndCheckIfInsert<T>(T entity) where T : IEntity
+        {
+            var cache = Cache<T>();
+            if (string.IsNullOrEmpty(entity.ID))
+            {
+                entity.ID = entity.GenerateNewID();
+                if (cache.HasCreatedOn) ((ICreatedOn)entity).CreatedOn = DateTime.UtcNow;
+                if (cache.HasModifiedOn) ((IModifiedOn)entity).ModifiedOn = DateTime.UtcNow;
+                return true;
+            }
+
+            if (cache.HasModifiedOn) ((IModifiedOn)entity).ModifiedOn = DateTime.UtcNow;
+            return false;
+        }
+
         /// <summary>
         /// Saves a complete entity replacing an existing entity or creating a new one if it does not exist. 
         /// If ID value is null, a new entity is created. If ID has a value, then existing entity is replaced.
@@ -14,11 +58,16 @@ public partial class DBContext
         /// <typeparam name="T">The type of entity</typeparam>
         /// <param name="entity">The instance to persist</param>
         /// <param name="cancellation">And optional cancellation token</param>
-        public Task InsertAsync<T>(T entity, CancellationToken cancellation = default) where T : IEntity
+        /// <param name="collectionName"></param>
+        /// <param name="collection"></param>
+        public Task InsertAsync<T>(T entity, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
         {
             SetModifiedBySingle(entity);
-            OnBeforeSave<T>()?.Invoke(entity);
-            return DB.InsertAsync(entity, Session, cancellation);
+            OnBeforeSave(entity);
+            PrepAndCheckIfInsert(entity);
+            return Session == null
+                   ? Collection(collectionName, collection).InsertOneAsync(entity, null, cancellation)
+                   : Collection(collectionName, collection).InsertOneAsync(Session, entity, null, cancellation);
         }
 
         /// <summary>
@@ -28,11 +77,22 @@ public Task InsertAsync<T>(T entity, CancellationToken cancellation = default) w
         /// <typeparam name="T">The type of entity</typeparam>
         /// <param name="entities">The entities to persist</param>
         /// <param name="cancellation">And optional cancellation token</param>
-        public Task<BulkWriteResult<T>> InsertAsync<T>(IEnumerable<T> entities, CancellationToken cancellation = default) where T : IEntity
+        /// <param name="collectionName"></param>
+        /// <param name="collection"></param>
+        public Task<BulkWriteResult<T>> InsertAsync<T>(IEnumerable<T> entities, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
         {
             SetModifiedByMultiple(entities);
-            foreach (var ent in entities) OnBeforeSave<T>()?.Invoke(ent);
-            return DB.InsertAsync(entities, Session, cancellation);
+            foreach (var ent in entities) OnBeforeSave(ent);
+
+            var models = entities.Select(ent =>
+            {
+                PrepAndCheckIfInsert(ent);
+                return new InsertOneModel<T>(ent);
+            }).ToList();
+
+            return Session == null
+                   ? Collection(collectionName, collection).BulkWriteAsync(models, _unOrdBlkOpts, cancellation)
+                   : Collection(collectionName, collection).BulkWriteAsync(Session, models, _unOrdBlkOpts, cancellation);
         }
     }
 }
diff --git a/MongoDB.Entities/DBContext/DBContext.PagedSearch.cs b/MongoDB.Entities/DBContext/DBContext.PagedSearch.cs
index 99818fb0c..891df99cd 100644
--- a/MongoDB.Entities/DBContext/DBContext.PagedSearch.cs
+++ b/MongoDB.Entities/DBContext/DBContext.PagedSearch.cs
@@ -1,4 +1,6 @@
-namespace MongoDB.Entities
+using MongoDB.Driver;
+
+namespace MongoDB.Entities
 {
     public partial class DBContext
     {
@@ -6,9 +8,9 @@ public partial class DBContext
         /// Represents an aggregation query that retrieves results with easy paging support.
         /// </summary>
         /// <typeparam name="T">Any class that implements IEntity</typeparam>
-        public PagedSearch<T> PagedSearch<T>() where T : IEntity
+        public PagedSearch<T> PagedSearch<T>(string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
         {
-            return new PagedSearch<T>(Session, _globalFilters, tenantPrefix);
+            return new PagedSearch<T>(this, Collection(collectionName, collection));
         }
 
         /// <summary>
@@ -16,9 +18,9 @@ public PagedSearch<T> PagedSearch<T>() where T : IEntity
         /// </summary>
         /// <typeparam name="T">Any class that implements IEntity</typeparam>
         /// <typeparam name="TProjection">The type you'd like to project the results to.</typeparam>
-        public PagedSearch<T, TProjection> PagedSearch<T, TProjection>() where T : IEntity
+        public PagedSearch<T, TProjection> PagedSearch<T, TProjection>(string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
         {
-            return new PagedSearch<T, TProjection>(Session, _globalFilters, tenantPrefix);
+            return new PagedSearch<T, TProjection>(this, Collection(collectionName, collection));
         }
     }
 }
diff --git a/MongoDB.Entities/DBContext/DBContext.Pipeline.cs b/MongoDB.Entities/DBContext/DBContext.Pipeline.cs
index 927d9eeab..cd35efeed 100644
--- a/MongoDB.Entities/DBContext/DBContext.Pipeline.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Pipeline.cs
@@ -2,6 +2,7 @@
 using MongoDB.Bson.Serialization;
 using MongoDB.Driver;
 using System.Collections.Generic;
+using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -19,9 +20,14 @@ public partial class DBContext
         /// <param name="options">The options for the aggregation. This is not required.</param>
         /// <param name="cancellation">An optional cancellation token</param>
         /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
-        public Task<IAsyncCursor<TResult>> PipelineCursorAsync<T, TResult>(Template<T, TResult> template, AggregateOptions options = null, CancellationToken cancellation = default, bool ignoreGlobalFilters = false) where T : IEntity
+        /// <param name="collectionName"></param>
+        /// <param name="collection"></param>
+        public Task<IAsyncCursor<TResult>> PipelineCursorAsync<T, TResult>(Template<T, TResult> template, AggregateOptions? options = null, CancellationToken cancellation = default, bool ignoreGlobalFilters = false, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
         {
-            return DB.PipelineCursorAsync(MergeGlobalFilter(template, ignoreGlobalFilters), options, Session, cancellation);
+            template = MergeTemplateGlobalFilter(template, ignoreGlobalFilters);
+            return Session == null
+                ? Collection(collectionName, collection).AggregateAsync(template.ToPipeline(), options, cancellation)
+                : Collection(collectionName, collection).AggregateAsync(Session, template.ToPipeline(), options, cancellation);
         }
 
         /// <summary>
@@ -34,9 +40,19 @@ public Task<IAsyncCursor<TResult>> PipelineCursorAsync<T, TResult>(Template<T, T
         /// <param name="options">The options for the aggregation. This is not required.</param>
         /// <param name="cancellation">An optional cancellation token</param>
         /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
-        public Task<List<TResult>> PipelineAsync<T, TResult>(Template<T, TResult> template, AggregateOptions options = null, CancellationToken cancellation = default, bool ignoreGlobalFilters = false) where T : IEntity
+        /// <param name="collectionName"></param>
+        /// <param name="collection"></param>
+        public async Task<List<TResult>> PipelineAsync<T, TResult>(Template<T, TResult> template, AggregateOptions? options = null, CancellationToken cancellation = default, bool ignoreGlobalFilters = false, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
         {
-            return DB.PipelineAsync(MergeGlobalFilter(template, ignoreGlobalFilters), options, Session, cancellation);
+            var list = new List<TResult>();
+            using (var cursor = await PipelineCursorAsync(template, options, cancellation, ignoreGlobalFilters: ignoreGlobalFilters, collectionName: collectionName, collection: collection).ConfigureAwait(false))
+            {
+                while (await cursor.MoveNextAsync(cancellation).ConfigureAwait(false))
+                {
+                    list.AddRange(cursor.Current);
+                }
+            }
+            return list;
         }
 
         /// <summary>
@@ -49,9 +65,17 @@ public Task<List<TResult>> PipelineAsync<T, TResult>(Template<T, TResult> templa
         /// <param name="options">The options for the aggregation. This is not required.</param>
         /// <param name="cancellation">An optional cancellation token</param>
         /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
-        public Task<TResult> PipelineSingleAsync<T, TResult>(Template<T, TResult> template, AggregateOptions options = null, CancellationToken cancellation = default, bool ignoreGlobalFilters = false) where T : IEntity
+        /// <param name="collectionName"></param>
+        /// <param name="collection"></param>
+        public async Task<TResult> PipelineSingleAsync<T, TResult>(Template<T, TResult> template, AggregateOptions? options = null, CancellationToken cancellation = default, bool ignoreGlobalFilters = false, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
         {
-            return DB.PipelineSingleAsync(MergeGlobalFilter(template, ignoreGlobalFilters), options, Session, cancellation);
+
+            AggregateOptions opts = options ?? new AggregateOptions();
+            opts.BatchSize = 2;
+
+            using var cursor = await PipelineCursorAsync(template, opts, cancellation, ignoreGlobalFilters: ignoreGlobalFilters, collectionName: collectionName, collection: collection).ConfigureAwait(false);
+            await cursor.MoveNextAsync(cancellation).ConfigureAwait(false);
+            return cursor.Current.SingleOrDefault();
         }
 
         /// <summary>
@@ -64,19 +88,25 @@ public Task<TResult> PipelineSingleAsync<T, TResult>(Template<T, TResult> templa
         /// <param name="options">The options for the aggregation. This is not required.</param>
         /// <param name="cancellation">An optional cancellation token</param>
         /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
-        public Task<TResult> PipelineFirstAsync<T, TResult>(Template<T, TResult> template, AggregateOptions options = null, CancellationToken cancellation = default, bool ignoreGlobalFilters = false) where T : IEntity
+        public async Task<TResult> PipelineFirstAsync<T, TResult>(Template<T, TResult> template, AggregateOptions? options = null, CancellationToken cancellation = default, bool ignoreGlobalFilters = false, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
         {
-            return DB.PipelineFirstAsync(MergeGlobalFilter(template, ignoreGlobalFilters), options, Session, cancellation);
+
+            var opts = options ?? new AggregateOptions();
+            opts.BatchSize = 1;
+
+            using var cursor = await PipelineCursorAsync(template, opts, cancellation, ignoreGlobalFilters: ignoreGlobalFilters, collectionName: collectionName, collection: collection).ConfigureAwait(false);
+            await cursor.MoveNextAsync(cancellation).ConfigureAwait(false);
+            return cursor.Current.SingleOrDefault();
         }
 
-        private Template<T, TResult> MergeGlobalFilter<T, TResult>(Template<T, TResult> template, bool ignoreGlobalFilters) where T : IEntity
+        private Template<T, TResult> MergeTemplateGlobalFilter<T, TResult>(Template<T, TResult> template, bool ignoreGlobalFilters) where T : IEntity
         {
             //WARNING: this has to do the same thing as Logic.MergeGlobalFilter method
             //         if the following logic changes, update the other method also
 
-            if (!ignoreGlobalFilters && _globalFilters.Count > 0 && _globalFilters.TryGetValue(typeof(T), out var gFilter))
+            if (!ignoreGlobalFilters && GlobalFilters.Count > 0 && GlobalFilters.TryGetValue(typeof(T), out var gFilter))
             {
-                BsonDocument filter = null;
+                BsonDocument? filter = null;
 
                 switch (gFilter.filterDef)
                 {
diff --git a/MongoDB.Entities/DBContext/DBContext.Queryable.cs b/MongoDB.Entities/DBContext/DBContext.Queryable.cs
index 608c0627a..cb79264ca 100644
--- a/MongoDB.Entities/DBContext/DBContext.Queryable.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Queryable.cs
@@ -11,13 +11,15 @@ public partial class DBContext
         /// <param name="options">The aggregate options</param>
         /// <typeparam name="T">The type of entity</typeparam>
         /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
-        public IMongoQueryable<T> Queryable<T>(AggregateOptions? options = null, bool ignoreGlobalFilters = false) where T : IEntity
+        /// <param name="collectionName"></param>
+        /// <param name="collection"></param>
+        public IMongoQueryable<T> Queryable<T>(AggregateOptions? options = null, bool ignoreGlobalFilters = false, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
         {
             var globalFilter = Logic.MergeWithGlobalFilter(ignoreGlobalFilters, _globalFilters, Builders<T>.Filter.Empty);
-
+            collection = Collection(collectionName, collection);
             var q = Session == null
-               ? CollectionFor<T>().AsQueryable(options)
-               : CollectionFor<T>().AsQueryable(Session, options);
+               ? collection.AsQueryable(options)
+               : collection.AsQueryable(Session, options);
 
             if (globalFilter != Builders<T>.Filter.Empty)
             {
diff --git a/MongoDB.Entities/DBContext/DBContext.Replace.cs b/MongoDB.Entities/DBContext/DBContext.Replace.cs
index f8eb9e984..b831a2f90 100644
--- a/MongoDB.Entities/DBContext/DBContext.Replace.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Replace.cs
@@ -1,4 +1,6 @@
-namespace MongoDB.Entities
+using MongoDB.Driver;
+
+namespace MongoDB.Entities
 {
     public partial class DBContext
     {
@@ -7,10 +9,10 @@ public partial class DBContext
         /// <para>TIP: Only the first matched entity will be replaced</para>
         /// </summary>
         /// <typeparam name="T">The type of entity</typeparam>
-        public Replace<T> Replace<T>() where T : IEntity
+        public Replace<T> Replace<T>(string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
         {
             ThrowIfModifiedByIsEmpty<T>();
-            return new Replace<T>(Session, ModifiedBy, _globalFilters, OnBeforeSave<T>(), tenantPrefix);
+            return new Replace<T>(this, Collection(collectionName, collection), OnBeforeSave<T>);
         }
     }
 }
diff --git a/MongoDB.Entities/DBContext/DBContext.Save.cs b/MongoDB.Entities/DBContext/DBContext.Save.cs
index c79ebd972..bde3f9848 100644
--- a/MongoDB.Entities/DBContext/DBContext.Save.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Save.cs
@@ -3,6 +3,7 @@
 using MongoDB.Driver;
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Linq.Expressions;
 using System.Threading;
 using System.Threading.Tasks;
@@ -18,11 +19,23 @@ public partial class DBContext
         /// <typeparam name="T">The type of entity</typeparam>
         /// <param name="entity">The instance to persist</param>
         /// <param name="cancellation">And optional cancellation token</param>
-        public Task SaveAsync<T>(T entity, CancellationToken cancellation = default) where T : IEntity
+        /// <param name="collectionName"></param>
+        /// <param name="collection"></param>
+        public Task SaveAsync<T>(T entity, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
         {
             SetModifiedBySingle(entity);
-            OnBeforeSave<T>()?.Invoke(entity);
-            return DB.SaveAsync(entity, Session, cancellation);
+            OnBeforeSave(entity);
+            collection = Collection(collectionName, collection);
+            if (PrepAndCheckIfInsert(entity))
+            {
+                return Session is null
+                       ? collection.InsertOneAsync(entity, null, cancellation)
+                       : collection.InsertOneAsync(Session, entity, null, cancellation);
+            }
+
+            return Session == null
+                   ? collection.ReplaceOneAsync(x => x.ID == entity.ID, entity, new ReplaceOptions { IsUpsert = true }, cancellation)
+                   : collection.ReplaceOneAsync(Session, x => x.ID == entity.ID, entity, new ReplaceOptions { IsUpsert = true }, cancellation);
         }
 
         /// <summary>
@@ -32,11 +45,32 @@ public Task SaveAsync<T>(T entity, CancellationToken cancellation = default) whe
         /// <typeparam name="T">The type of entity</typeparam>
         /// <param name="entities">The entities to persist</param>
         /// <param name="cancellation">And optional cancellation token</param>
-        public Task<BulkWriteResult<T>> SaveAsync<T>(IEnumerable<T> entities, CancellationToken cancellation = default) where T : IEntity
+        /// <param name="collectionName"></param>
+        /// <param name="collection"></param>
+        public Task<BulkWriteResult<T>> SaveAsync<T>(IEnumerable<T> entities, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
         {
             SetModifiedByMultiple(entities);
-            foreach (var ent in entities) OnBeforeSave<T>()?.Invoke(ent);
-            return DB.SaveAsync(entities, Session, cancellation);
+            foreach (var ent in entities) OnBeforeSave(ent);
+
+
+            var models = entities.Select<T, WriteModel<T>>(ent =>
+            {
+                if (PrepAndCheckIfInsert(ent))
+                {
+                    return new InsertOneModel<T>(ent);
+                }
+                else
+                {
+                    return new ReplaceOneModel<T>(
+                        filter: Builders<T>.Filter.Eq(e => e.ID, ent.ID),
+                        replacement: ent)
+                    { IsUpsert = true };
+                }
+            });
+
+            return Session == null
+                   ? Collection(collectionName, collection).BulkWriteAsync(models, _unOrdBlkOpts, cancellation)
+                   : Collection(collectionName, collection).BulkWriteAsync(Session, models, _unOrdBlkOpts, cancellation);
         }
 
         /// <summary>
@@ -49,11 +83,14 @@ public Task<BulkWriteResult<T>> SaveAsync<T>(IEnumerable<T> entities, Cancellati
         /// <param name="entity">The entity to save</param>
         /// <param name="members">x => new { x.PropOne, x.PropTwo }</param>
         /// <param name="cancellation">An optional cancellation token</param>
-        public Task<UpdateResult> SaveOnlyAsync<T>(T entity, Expression<Func<T, object>> members, CancellationToken cancellation = default) where T : IEntity
+        /// <param name="collectionName"></param>
+        /// <param name="collection"></param>
+        public Task<UpdateResult> SaveOnlyAsync<T>(T entity, Expression<Func<T, object>> members, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
         {
             SetModifiedBySingle(entity);
-            OnBeforeSave<T>()?.Invoke(entity);
-            return DB.SaveOnlyAsync(entity, members, Session, cancellation);
+            OnBeforeSave(entity);
+            return SavePartial(entity, members, cancellation, collectionName: collectionName, collection: collection);
+
         }
 
         /// <summary>
@@ -66,11 +103,13 @@ public Task<UpdateResult> SaveOnlyAsync<T>(T entity, Expression<Func<T, object>>
         /// <param name="entities">The batch of entities to save</param>
         /// <param name="members">x => new { x.PropOne, x.PropTwo }</param>
         /// <param name="cancellation">An optional cancellation token</param>
-        public Task<BulkWriteResult<T>> SaveOnlyAsync<T>(IEnumerable<T> entities, Expression<Func<T, object>> members, CancellationToken cancellation = default) where T : IEntity
+        /// <param name="collectionName"></param>
+        /// <param name="collection"></param>
+        public Task<BulkWriteResult<T>> SaveOnlyAsync<T>(IEnumerable<T> entities, Expression<Func<T, object>> members, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
         {
             SetModifiedByMultiple(entities);
-            foreach (var ent in entities) OnBeforeSave<T>()?.Invoke(ent);
-            return DB.SaveOnlyAsync(entities, members, Session, cancellation);
+            foreach (var ent in entities) OnBeforeSave(ent);
+            return SavePartial(entities, members, cancellation, collectionName: collectionName, collection: collection);
         }
 
         /// <summary>
@@ -83,11 +122,13 @@ public Task<BulkWriteResult<T>> SaveOnlyAsync<T>(IEnumerable<T> entities, Expres
         /// <param name="entity">The entity to save</param>
         /// <param name="members">x => new { x.PropOne, x.PropTwo }</param>
         /// <param name="cancellation">An optional cancellation token</param>
-        public Task<UpdateResult> SaveExceptAsync<T>(T entity, Expression<Func<T, object>> members, CancellationToken cancellation = default) where T : IEntity
+        /// <param name="collectionName"></param>
+        /// <param name="collection"></param>
+        public Task<UpdateResult> SaveExceptAsync<T>(T entity, Expression<Func<T, object>> members, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
         {
             SetModifiedBySingle(entity);
-            OnBeforeSave<T>()?.Invoke(entity);
-            return DB.SaveExceptAsync(entity, members, Session, cancellation);
+            OnBeforeSave(entity);
+            return SavePartial(entity, members, cancellation, true, collectionName: collectionName, collection: collection);
         }
 
         /// <summary>
@@ -100,11 +141,13 @@ public Task<UpdateResult> SaveExceptAsync<T>(T entity, Expression<Func<T, object
         /// <param name="entities">The batch of entities to save</param>
         /// <param name="members">x => new { x.PropOne, x.PropTwo }</param>
         /// <param name="cancellation">An optional cancellation token</param>
-        public Task<BulkWriteResult<T>> SaveExceptAsync<T>(IEnumerable<T> entities, Expression<Func<T, object>> members, CancellationToken cancellation = default) where T : IEntity
+        /// <param name="collectionName"></param>
+        /// <param name="collection"></param>
+        public Task<BulkWriteResult<T>> SaveExceptAsync<T>(IEnumerable<T> entities, Expression<Func<T, object>> members, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
         {
             SetModifiedByMultiple(entities);
-            foreach (var ent in entities) OnBeforeSave<T>()?.Invoke(ent);
-            return DB.SaveExceptAsync(entities, members, Session, cancellation);
+            foreach (var ent in entities) OnBeforeSave(ent);
+            return SavePartial(entities, members, cancellation, true, collectionName: collectionName, collection: collection);
         }
 
         /// <summary>
@@ -114,18 +157,64 @@ public Task<BulkWriteResult<T>> SaveExceptAsync<T>(IEnumerable<T> entities, Expr
         /// <typeparam name="T">The type of entity</typeparam>
         /// <param name="entity">The entity to save</param>
         /// <param name="cancellation">An optional cancellation token</param>
-        public Task<UpdateResult> SavePreservingAsync<T>(T entity, CancellationToken cancellation = default) where T : IEntity
+        /// <param name="collectionName"></param>
+        /// <param name="collection"></param>
+        public Task<UpdateResult> SavePreservingAsync<T>(T entity, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
         {
             SetModifiedBySingle(entity);
-            OnBeforeSave<T>()?.Invoke(entity);
-            return DB.SavePreservingAsync(entity, Session, cancellation);
+            OnBeforeSave(entity);
+            entity.ThrowIfUnsaved();
+            var cache = Cache<T>();
+            var propsToUpdate = cache.UpdatableProps(entity);
+
+            IEnumerable<string> propsToPreserve = new string[0];
+
+            var dontProps = propsToUpdate.Where(p => p.IsDefined(typeof(DontPreserveAttribute), false)).Select(p => p.Name);
+            var presProps = propsToUpdate.Where(p => p.IsDefined(typeof(PreserveAttribute), false)).Select(p => p.Name);
+
+            if (dontProps.Any() && presProps.Any())
+                throw new NotSupportedException("[Preseve] and [DontPreserve] attributes cannot be used together on the same entity!");
+
+            if (dontProps.Any())
+                propsToPreserve = propsToUpdate.Where(p => !dontProps.Contains(p.Name)).Select(p => p.Name);
+
+            if (presProps.Any())
+                propsToPreserve = propsToUpdate.Where(p => presProps.Contains(p.Name)).Select(p => p.Name);
+
+            if (!propsToPreserve.Any())
+                throw new ArgumentException("No properties are being preserved. Please use .SaveAsync() method instead!");
+
+            propsToUpdate = propsToUpdate.Where(p => !propsToPreserve.Contains(p.Name));
+
+            var propsToUpdateCount = propsToUpdate.Count();
+
+            if (propsToUpdateCount == 0)
+                throw new ArgumentException("At least one property must be not preserved!");
+
+            var defs = new List<UpdateDefinition<T>>(propsToUpdateCount);
+
+            foreach (var p in propsToUpdate)
+            {
+                if (p.Name == cache.ModifiedOnPropName)
+                    defs.Add(Builders<T>.Update.CurrentDate(cache.ModifiedOnPropName));
+                else
+                    defs.Add(Builders<T>.Update.Set(p.Name, p.GetValue(entity)));
+            }
+
+            return
+                Session == null
+                ? Collection(collectionName, collection).UpdateOneAsync(e => e.ID == entity.ID, Builders<T>.Update.Combine(defs), _updateOptions, cancellation)
+                : Collection(collectionName, collection).UpdateOneAsync(Session, e => e.ID == entity.ID, Builders<T>.Update.Combine(defs), _updateOptions, cancellation);
         }
 
         private void SetModifiedBySingle<T>(T entity) where T : IEntity
         {
-            ThrowIfModifiedByIsEmpty<T>();
             var cache = Cache<T>();
-            cache.ModifiedByProp?.SetValue(
+            if (cache.ModifiedByProp is null) 
+                return;
+            ThrowIfModifiedByIsEmpty<T>();
+
+            cache.ModifiedByProp.SetValue(
                 entity,
                 BsonSerializer.Deserialize(ModifiedBy.ToBson(), cache.ModifiedByProp.PropertyType));
             //note: we can't use an IModifiedBy interface because the above line needs a concrete type
@@ -135,7 +224,7 @@ private void SetModifiedBySingle<T>(T entity) where T : IEntity
         private void SetModifiedByMultiple<T>(IEnumerable<T> entities) where T : IEntity
         {
             var cache = Cache<T>();
-            if (Cache<T>().ModifiedByProp is null)
+            if (cache.ModifiedByProp is null)
                 return;
 
             ThrowIfModifiedByIsEmpty<T>();
diff --git a/MongoDB.Entities/DBContext/DBContext.Sequence.cs b/MongoDB.Entities/DBContext/DBContext.Sequence.cs
index 1f3ac8307..3d4f8f454 100644
--- a/MongoDB.Entities/DBContext/DBContext.Sequence.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Sequence.cs
@@ -5,16 +5,15 @@ namespace MongoDB.Entities
 {
     public partial class DBContext
     {
-        //NOTE: transaction support will not be added due to unpredictability with concurrency.
-
         /// <summary>
         /// Returns an atomically generated sequential number for the given Entity type everytime the method is called
         /// </summary>
         /// <typeparam name="T">The type of entity to get the next sequential number for</typeparam>
         /// <param name="cancellation">An optional cancellation token</param>
+        /// <remarks>transaction support will not be added due to unpredictability with concurrency.</remarks>
         public Task<ulong> NextSequentialNumberAsync<T>(CancellationToken cancellation = default) where T : IEntity
         {
-            return DB.NextSequentialNumberAsync(DB.CollectionName<T>(), cancellation, tenantPrefix);
+            return NextSequentialNumberAsync(CollectionName<T>(), cancellation);
         }
 
         /// <summary>
@@ -22,9 +21,15 @@ public Task<ulong> NextSequentialNumberAsync<T>(CancellationToken cancellation =
         /// </summary>
         /// <param name="sequenceName">The name of the sequence to get the next number for</param>
         /// <param name="cancellation">An optional cancellation token</param>
+        /// <remarks>transaction support will not be added due to unpredictability with concurrency.</remarks>
         public Task<ulong> NextSequentialNumberAsync(string sequenceName, CancellationToken cancellation = default)
         {
-            return DB.NextSequentialNumberAsync(sequenceName, cancellation, tenantPrefix);
+            return new UpdateAndGet<SequenceCounter, ulong>(this, Collection<SequenceCounter>(), onUpdateAction: null, defs: null)
+                .Match(s => s.ID == sequenceName)
+                .Modify(b => b.Inc(s => s.Count, 1ul))
+                .Option(o => o.IsUpsert = true)
+                .Project(s => s.Count)
+                .ExecuteAsync(cancellation);
         }
     }
 }
diff --git a/MongoDB.Entities/DBContext/DBContext.Transaction.cs b/MongoDB.Entities/DBContext/DBContext.Transaction.cs
index 3f03ebb57..9cfda4bcc 100644
--- a/MongoDB.Entities/DBContext/DBContext.Transaction.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Transaction.cs
@@ -7,20 +7,18 @@ namespace MongoDB.Entities
 {
     public partial class DBContext
     {
-
         /// <summary>
         /// Starts a transaction and returns a session object.
         /// <para>WARNING: Only one transaction is allowed per DBContext instance. 
         /// Call Session.Dispose() and assign a null to it before calling this method a second time. 
         /// Trying to start a second transaction for this DBContext instance will throw an exception.</para>
         /// </summary>
-        /// <param name="database">The name of the database to use for this transaction. default db is used if not specified</param>
         /// <param name="options">Client session options for this transaction</param>
-        public IClientSessionHandle Transaction(string database = default, ClientSessionOptions options = null)
+        public IClientSessionHandle Transaction(ClientSessionOptions? options = null)
         {
             if (Session is null)
             {
-                Session = DB.Database(database).Client.StartSession(options);
+                Session = Client.StartSession(options);
                 Session.StartTransaction();
                 return Session;
             }
@@ -29,29 +27,33 @@ public IClientSessionHandle Transaction(string database = default, ClientSession
                 "Only one transaction is allowed per DBContext instance. Dispose and nullify the Session before calling this method again!");
         }
 
-        /// <summary>
-        /// Starts a transaction and returns a session object for a given entity type.
-        /// <para>WARNING: Only one transaction is allowed per DBContext instance. 
-        /// Call Session.Dispose() and assign a null to it before calling this method a second time. 
-        /// Trying to start a second transaction for this DBContext instance will throw an exception.</para>
-        /// </summary>
-        /// <typeparam name="T">The entity type to determine the database from for the transaction</typeparam>
-        /// <param name="options">Client session options (not required)</param>
-        public IClientSessionHandle Transaction<T>(ClientSessionOptions options = null) where T : IEntity
-        {
-            return Transaction(DB.DatabaseName<T>(tenantPrefix), options);
-        }
 
         /// <summary>
         /// Commits a transaction to MongoDB
         /// </summary>
         /// <param name="cancellation">An optional cancellation token</param>
-        public Task CommitAsync(CancellationToken cancellation = default) => Session.CommitTransactionAsync(cancellation);
+        public Task CommitAsync(CancellationToken cancellation = default)
+        {
+            if (Session is null)
+            {
+                throw new ArgumentNullException(nameof(Session), "Please call Transaction<T>() first before committing");
+            }
+
+            return Session.CommitTransactionAsync(cancellation);
+        }
 
         /// <summary>
         /// Aborts and rolls back a transaction
         /// </summary>
         /// <param name="cancellation">An optional cancellation token</param>
-        public Task AbortAsync(CancellationToken cancellation = default) => Session.AbortTransactionAsync(cancellation);
+        public Task AbortAsync(CancellationToken cancellation = default)
+        {
+            if (Session is null)
+            {
+                throw new ArgumentNullException(nameof(Session), "Please call Transaction<T>() first before aborting");
+            }
+
+            return Session.AbortTransactionAsync(cancellation);
+        }
     }
 }
diff --git a/MongoDB.Entities/DBContext/DBContext.Update.cs b/MongoDB.Entities/DBContext/DBContext.Update.cs
index 928b0fe87..f38e78087 100644
--- a/MongoDB.Entities/DBContext/DBContext.Update.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Update.cs
@@ -1,4 +1,7 @@
-namespace MongoDB.Entities
+using MongoDB.Driver;
+using System.Reflection;
+
+namespace MongoDB.Entities
 {
     public partial class DBContext
     {
@@ -6,13 +9,13 @@ public partial class DBContext
         /// Starts an update command for the given entity type
         /// </summary>
         /// <typeparam name="T">The type of entity</typeparam>
-        public Update<T> Update<T>() where T : IEntity
+        public Update<T> Update<T>(string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
         {
-            var cmd = new Update<T>(this, CollectionFor<T>(), _globalFilters, OnBeforeUpdate<T, Update<T>>());
-            if (Cache<T>().ModifiedByProp != null)
+            var cmd = new Update<T>(this, Collection(collectionName, collection), OnBeforeUpdate<T, Update<T>>);
+            if (Cache<T>().ModifiedByProp is PropertyInfo ModifiedByProp)
             {
                 ThrowIfModifiedByIsEmpty<T>();
-                cmd.Modify(b => b.Set(Cache<T>().ModifiedByProp.Name, ModifiedBy));
+                cmd.Modify(b => b.Set(ModifiedByProp.Name, ModifiedBy));
             }
             return cmd;
         }
@@ -21,9 +24,9 @@ public Update<T> Update<T>() where T : IEntity
         /// Starts an update-and-get command for the given entity type
         /// </summary>
         /// <typeparam name="T">The type of entity</typeparam>
-        public UpdateAndGet<T, T> UpdateAndGet<T>() where T : IEntity
+        public UpdateAndGet<T, T> UpdateAndGet<T>(string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
         {
-            return UpdateAndGet<T, T>();
+            return UpdateAndGet<T, T>(collectionName, collection);
         }
 
         /// <summary>
@@ -31,13 +34,13 @@ public UpdateAndGet<T, T> UpdateAndGet<T>() where T : IEntity
         /// </summary>
         /// <typeparam name="T">The type of entity</typeparam>
         /// <typeparam name="TProjection">The type of the end result</typeparam>
-        public UpdateAndGet<T, TProjection> UpdateAndGet<T, TProjection>() where T : IEntity
+        public UpdateAndGet<T, TProjection> UpdateAndGet<T, TProjection>(string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
         {
-            var cmd = new UpdateAndGet<T, TProjection>(this, CollectionFor<T>(), _globalFilters, OnBeforeUpdate<T, UpdateAndGet<T, TProjection>>());
-            if (Cache<T>().ModifiedByProp != null)
+            var cmd = new UpdateAndGet<T, TProjection>(this, Collection(collectionName, collection), OnBeforeUpdate<T, UpdateAndGet<T, TProjection>>);
+            if (Cache<T>().ModifiedByProp is PropertyInfo ModifiedByProp)
             {
                 ThrowIfModifiedByIsEmpty<T>();
-                cmd.Modify(b => b.Set(Cache<T>().ModifiedByProp.Name, ModifiedBy));
+                cmd.Modify(b => b.Set(ModifiedByProp.Name, ModifiedBy));
             }
             return cmd;
         }
diff --git a/MongoDB.Entities/DBContext/DBContext.Watcher.cs b/MongoDB.Entities/DBContext/DBContext.Watcher.cs
index b1801837b..451c0821f 100644
--- a/MongoDB.Entities/DBContext/DBContext.Watcher.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Watcher.cs
@@ -1,4 +1,5 @@
-using System.Collections.Generic;
+using MongoDB.Driver;
+using System.Collections.Generic;
 
 namespace MongoDB.Entities
 {
@@ -11,15 +12,23 @@ public partial class DBContext
         /// </summary>
         /// <typeparam name="T">The entity type to get a watcher for</typeparam>
         /// <param name="name">A unique name for the watcher of this entity type. Names can be duplicate among different entity types.</param>
-        public Watcher<T> Watcher<T>(string name) where T : IEntity
+        /// <param name="collectionName"></param>
+        /// <param name="collection"></param>
+        public Watcher<T> Watcher<T>(string name, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
         {
-            return DB.Watcher<T>(name, tenantPrefix);
+            var cache = Cache<T>();
+            if (cache.Watchers.TryGetValue(name.ToLowerInvariant().Trim(), out Watcher<T> watcher))
+                return watcher;
+
+            watcher = new Watcher<T>(name.ToLowerInvariant().Trim(), this, Collection(collectionName, collection));
+            cache.Watchers.TryAdd(name, watcher);
+            return watcher;
         }
 
         /// <summary>
         /// Returns all the watchers for a given entity type
         /// </summary>
         /// <typeparam name="T">The entity type to get the watcher of</typeparam>
-        public IEnumerable<Watcher<T>> Watchers<T>() where T : IEntity => DB.Watchers<T>();
+        public IEnumerable<Watcher<T>> Watchers<T>() where T : IEntity => Cache<T>().Watchers.Values;
     }
 }
diff --git a/MongoDB.Entities/DBContext/DBContext.cs b/MongoDB.Entities/DBContext/DBContext.cs
index 4f06b90d9..28f618cf8 100644
--- a/MongoDB.Entities/DBContext/DBContext.cs
+++ b/MongoDB.Entities/DBContext/DBContext.cs
@@ -1,4 +1,7 @@
-using MongoDB.Bson.Serialization;
+using MongoDB.Bson;
+using MongoDB.Bson.Serialization;
+using MongoDB.Bson.Serialization.Conventions;
+using MongoDB.Bson.Serialization.Serializers;
 using MongoDB.Driver;
 using System;
 using System.Collections.Concurrent;
@@ -8,295 +11,334 @@
 using System.Threading;
 using System.Threading.Tasks;
 #nullable enable
-namespace MongoDB.Entities
+namespace MongoDB.Entities;
+
+/// <summary>
+/// Wraps an IMongoDatabase to provide extra functionality
+/// </summary>
+public partial class DBContext : IMongoDatabase
 {
     /// <summary>
-    /// This db context class can be used as an alternative entry point instead of the DB static class. 
+    /// Returns the session object used for transactions
     /// </summary>
-    public partial class DBContext : IMongoDatabase
-    {
-        /// <summary>
-        /// Returns the session object used for transactions
-        /// </summary>
-        public IClientSessionHandle? Session { get; protected set; }
+    public IClientSessionHandle? Session { get; protected set; }
 
 
-        public MongoServerContext MongoServerContext { get; set; }
-        public IMongoDatabase Database { get; set; }
-        public DBContextOptions Options { get; set; }
+    public MongoServerContext MongoServerContext { get; }
+    public IMongoDatabase Database { get; }
+    public DBContextOptions Options { get; }
 
-        /// <summary>
-        /// wrapper around <see cref="MongoServerContext.ModifiedBy"/> so that we don't break the public api
-        /// </summary>
-        public ModifiedBy? ModifiedBy
+    /// <summary>
+    /// wrapper around <see cref="MongoServerContext.ModifiedBy"/> so that we don't break the public api
+    /// </summary>
+    public ModifiedBy? ModifiedBy
+    {
+        get
         {
-            get
-            {
-                return MongoServerContext.ModifiedBy;
-            }
-            [Obsolete("Use MongoContext.Options.ModifiedBy = value instead")]
-            set
-            {
-                MongoServerContext.Options.ModifiedBy = value;
-            }
+            return MongoServerContext.ModifiedBy;
+        }
+        [Obsolete("Use MongoContext.Options.ModifiedBy = value instead")]
+        set
+        {
+            MongoServerContext.Options.ModifiedBy = value;
         }
+    }
 
-        public IMongoClient Client => MongoServerContext;
+    public IMongoClient Client => MongoServerContext;
 
-        public DatabaseNamespace DatabaseNamespace => Database.DatabaseNamespace;
+    public DatabaseNamespace DatabaseNamespace => Database.DatabaseNamespace;
 
-        public MongoDatabaseSettings Settings => Database.Settings;
+    public MongoDatabaseSettings Settings => Database.Settings;
 
-        private Dictionary<Type, (object filterDef, bool prepend)>? _globalFilters;
-        internal Dictionary<Type, (object filterDef, bool prepend)> GlobalFilters => _globalFilters ??= new();
+    private Dictionary<Type, (object filterDef, bool prepend)>? _globalFilters;
+    internal Dictionary<Type, (object filterDef, bool prepend)> GlobalFilters => _globalFilters ??= new();
 
-        /// <summary>
-        /// Copy constructor
-        /// </summary>
-        /// <param name="other"></param>
-        public DBContext(DBContext other)
-        {
-            MongoServerContext = other.MongoServerContext;
-            Database = other.Database;
-            Options = other.Options;
-        }
-        public DBContext(MongoServerContext mongoContext, IMongoDatabase database, DBContextOptions? options = null)
-        {
-            MongoServerContext = mongoContext;
-            Database = database;
-            Options = options ?? new();
-        }
-        public DBContext(MongoServerContext mongoContext, string database, MongoDatabaseSettings? settings = null, DBContextOptions? options = null)
-        {
-            MongoServerContext = mongoContext;
-            Options = options ?? new();
-            Database = mongoContext.GetDatabase(database, settings);
-        }
+    /// <summary>
+    /// Copy constructor
+    /// </summary>
+    /// <param name="other"></param>
+    public DBContext(DBContext other)
+    {
+        MongoServerContext = other.MongoServerContext;
+        Database = other.Database;
+        Options = other.Options;
+    }
+    public DBContext(MongoServerContext mongoContext, IMongoDatabase database, DBContextOptions? options = null)
+    {
+        MongoServerContext = mongoContext;
+        Database = database;
+        Options = options ?? new();
+    }
+    public DBContext(MongoServerContext mongoContext, string database, MongoDatabaseSettings? settings = null, DBContextOptions? options = null)
+    {
+        MongoServerContext = mongoContext;
+        Options = options ?? new();
+        Database = mongoContext.Client.GetDatabase(database, settings);
+    }
 
-        /// <summary>
-        /// Initializes a DBContext instance with the given connection parameters.
-        /// <para>TIP: network connection is deferred until the first actual operation.</para>
-        /// </summary>
-        /// <param name="database">Name of the database</param>
-        /// <param name="host">Address of the MongoDB server</param>
-        /// <param name="port">Port number of the server</param>
-        /// <param name="modifiedBy">An optional ModifiedBy instance. 
-        /// When supplied, all save/update operations performed via this DBContext instance will set the value on entities that has a property of type ModifiedBy. 
-        /// You can even inherit from the ModifiedBy class and add your own properties to it. 
-        /// Only one ModifiedBy property is allowed on a single entity type.</param>
-        public DBContext(string database, string host = "127.0.0.1", int port = 27017, ModifiedBy? modifiedBy = null)
-        {
-            MongoServerContext = new MongoServerContext(
-                client: new MongoClient(
-                    new MongoClientSettings
-                    {
-                        Server = new MongoServerAddress(host, port)
-                    }),
-                options: new()
+    /// <summary>
+    /// Initializes a DBContext instance with the given connection parameters.
+    /// <para>TIP: network connection is deferred until the first actual operation.</para>
+    /// </summary>
+    /// <param name="database">Name of the database</param>
+    /// <param name="host">Address of the MongoDB server</param>
+    /// <param name="port">Port number of the server</param>
+    /// <param name="modifiedBy">An optional ModifiedBy instance. 
+    /// When supplied, all save/update operations performed via this DBContext instance will set the value on entities that has a property of type ModifiedBy. 
+    /// You can even inherit from the ModifiedBy class and add your own properties to it. 
+    /// Only one ModifiedBy property is allowed on a single entity type.</param>
+    public DBContext(string database, string host = "127.0.0.1", int port = 27017, ModifiedBy? modifiedBy = null)
+    {
+        MongoServerContext = new MongoServerContext(
+            client: new MongoClient(
+                new MongoClientSettings
                 {
-                    ModifiedBy = modifiedBy
-                });
-            Options = new();
-            Database = MongoServerContext.GetDatabase(database);
-        }
+                    Server = new MongoServerAddress(host, port)
+                }),
+            options: new()
+            {
+                ModifiedBy = modifiedBy
+            });
+        Options = new();
+        Database = MongoServerContext.Client.GetDatabase(database);
+    }
 
-        /// <summary>
-        /// Initializes a DBContext instance with the given connection parameters.
-        /// <para>TIP: network connection is deferred until the first actual operation.</para>
-        /// </summary>
-        /// <param name="database">Name of the database</param>
-        /// <param name="settings">A MongoClientSettings object</param>
-        /// <param name="modifiedBy">An optional ModifiedBy instance. 
-        /// When supplied, all save/update operations performed via this DBContext instance will set the value on entities that has a property of type ModifiedBy. 
-        /// You can even inherit from the ModifiedBy class and add your own properties to it. 
-        /// Only one ModifiedBy property is allowed on a single entity type.</param>
-        public DBContext(string database, MongoClientSettings settings, ModifiedBy? modifiedBy = null)
-        {
-            MongoServerContext = new MongoServerContext(
-               client: new MongoClient(settings),
-               options: new()
-               {
-                   ModifiedBy = modifiedBy
-               });
-            Options = new();
-            Database = MongoServerContext.GetDatabase(database);
-        }
+    /// <summary>
+    /// Initializes a DBContext instance with the given connection parameters.
+    /// <para>TIP: network connection is deferred until the first actual operation.</para>
+    /// </summary>
+    /// <param name="database">Name of the database</param>
+    /// <param name="settings">A MongoClientSettings object</param>
+    /// <param name="modifiedBy">An optional ModifiedBy instance. 
+    /// When supplied, all save/update operations performed via this DBContext instance will set the value on entities that has a property of type ModifiedBy. 
+    /// You can even inherit from the ModifiedBy class and add your own properties to it. 
+    /// Only one ModifiedBy property is allowed on a single entity type.</param>
+    public DBContext(string database, MongoClientSettings settings, ModifiedBy? modifiedBy = null)
+    {
+        MongoServerContext = new MongoServerContext(
+           client: new MongoClient(settings),
+           options: new()
+           {
+               ModifiedBy = modifiedBy
+           });
+        Options = new();
+        Database = MongoServerContext.Client.GetDatabase(database);
+    }
 
+    static DBContext()
+    {
+        InitStatic();
+    }
+    private static bool _isInit;
+    public static void InitStatic()
+    {
+        if (_isInit)
+            return;
+        _isInit = true;
+        BsonSerializer.RegisterSerializer(new DateSerializer());
+        BsonSerializer.RegisterSerializer(new FuzzyStringSerializer());
+        BsonSerializer.RegisterSerializer(typeof(decimal), new DecimalSerializer(BsonType.Decimal128));
+        BsonSerializer.RegisterSerializer(typeof(decimal?), new NullableSerializer<decimal>(new DecimalSerializer(BsonType.Decimal128)));
+
+        ConventionRegistry.Register(
+            "DefaultConventions",
+            new ConventionPack
+            {
+                        new IgnoreExtraElementsConvention(true),
+                        new IgnoreManyPropsConvention()
+            },
+            _ => true);
+    }
 
-        /// <summary>
-        /// Instantiates a DBContext instance
-        /// <para>TIP: will throw an error if no connections have been initialized</para>
-        /// </summary>
-        /// <param name="modifiedBy">An optional ModifiedBy instance. 
-        /// When supplied, all save/update operations performed via this DBContext instance will set the value on entities that has a property of type ModifiedBy. 
-        /// You can even inherit from the ModifiedBy class and add your own properties to it. 
-        /// Only one ModifiedBy property is allowed on a single entity type.</param>
-        [Obsolete("This constructor is obsolete, you can only create a DBContext after knowing the database name")]
-        public DBContext(ModifiedBy? modifiedBy = null) : this("default", modifiedBy: modifiedBy)
-        {
-        }
 
 
-        /// <summary>
-        /// This event hook will be trigged right before an entity is persisted
-        /// </summary>
-        /// <typeparam name="T">Any entity that implements IEntity</typeparam>
-        protected virtual Action<T>? OnBeforeSave<T>() where T : IEntity
-        {
-            return null;
-        }
+    /// <summary>
+    /// Instantiates a DBContext instance
+    /// <para>TIP: will throw an error if no connections have been initialized</para>
+    /// </summary>
+    /// <param name="modifiedBy">An optional ModifiedBy instance. 
+    /// When supplied, all save/update operations performed via this DBContext instance will set the value on entities that has a property of type ModifiedBy. 
+    /// You can even inherit from the ModifiedBy class and add your own properties to it. 
+    /// Only one ModifiedBy property is allowed on a single entity type.</param>
+    [Obsolete("This constructor is obsolete, you can only create a DBContext after knowing the database name")]
+    public DBContext(ModifiedBy? modifiedBy = null) : this("default", modifiedBy: modifiedBy)
+    {
+    }
 
-        /// <summary>
-        /// This event hook will be triggered right before an update/replace command is executed
-        /// </summary>
-        /// <typeparam name="T">Any entity that implements IEntity</typeparam>
-        /// <typeparam name="TSelf">Any entity that implements IEntity</typeparam>
-        protected virtual Action<UpdateBase<T, TSelf>>? OnBeforeUpdate<T, TSelf>() where T : IEntity where TSelf : UpdateBase<T, TSelf>
-        {
-            return null;
-        }
 
+    /// <summary>
+    /// This event hook will be trigged right before an entity is persisted
+    /// </summary>
+    /// <typeparam name="T">Any entity that implements IEntity</typeparam>
+    protected virtual void OnBeforeSave<T>(T entity) where T : IEntity
+    {
+    }
 
+    /// <summary>
+    /// This event hook will be triggered right before an update/replace command is executed
+    /// </summary>
+    /// <typeparam name="T">Any entity that implements IEntity</typeparam>
+    /// <typeparam name="TSelf">Any entity that implements IEntity</typeparam>
+    protected virtual void OnBeforeUpdate<T, TSelf>(UpdateBase<T, TSelf> updateBase) where T : IEntity where TSelf : UpdateBase<T, TSelf>
+    {
+    }
 
-        /// <summary>
-        /// Specify a global filter to be applied to all operations performed with this DBContext
-        /// </summary>
-        /// <typeparam name="T">The type of Entity this global filter should be applied to</typeparam>
-        /// <param name="filter">x => x.Prop1 == "some value"</param>
-        /// <param name="prepend">Set to true if you want to prepend this global filter to your operation filters instead of being appended</param> 
-        protected void SetGlobalFilter<T>(Expression<Func<T, bool>> filter, bool prepend = false) where T : IEntity
-        {
-            SetGlobalFilter(Builders<T>.Filter.Where(filter), prepend);
-        }
 
-        /// <summary>
-        /// Specify a global filter to be applied to all operations performed with this DBContext
-        /// </summary>
-        /// <typeparam name="T">The type of Entity this global filter should be applied to</typeparam>
-        /// <param name="filter">b => b.Eq(x => x.Prop1, "some value")</param>
-        /// <param name="prepend">Set to true if you want to prepend this global filter to your operation filters instead of being appended</param>
-        protected void SetGlobalFilter<T>(Func<FilterDefinitionBuilder<T>, FilterDefinition<T>> filter, bool prepend = false) where T : IEntity
-        {
-            SetGlobalFilter(filter(Builders<T>.Filter), prepend);
-        }
 
-        /// <summary>
-        /// Specify a global filter to be applied to all operations performed with this DBContext
-        /// </summary>
-        /// <typeparam name="T">The type of Entity this global filter should be applied to</typeparam>
-        /// <param name="filter">A filter definition to be applied</param>
-        /// <param name="prepend">Set to true if you want to prepend this global filter to your operation filters instead of being appended</param>
-        protected void SetGlobalFilter<T>(FilterDefinition<T> filter, bool prepend = false) where T : IEntity
-        {
-            AddFilter(typeof(T), (filter, prepend));
-        }
+    /// <summary>
+    /// Specify a global filter to be applied to all operations performed with this DBContext
+    /// </summary>
+    /// <typeparam name="T">The type of Entity this global filter should be applied to</typeparam>
+    /// <param name="filter">x => x.Prop1 == "some value"</param>
+    /// <param name="prepend">Set to true if you want to prepend this global filter to your operation filters instead of being appended</param> 
+    protected void SetGlobalFilter<T>(Expression<Func<T, bool>> filter, bool prepend = false) where T : IEntity
+    {
+        SetGlobalFilter(Builders<T>.Filter.Where(filter), prepend);
+    }
 
-        /// <summary>
-        /// Specify a global filter to be applied to all operations performed with this DBContext
-        /// </summary>
-        /// <param name="type">The type of Entity this global filter should be applied to</param>
-        /// <param name="jsonString">A JSON string filter definition to be applied</param>
-        /// <param name="prepend">Set to true if you want to prepend this global filter to your operation filters instead of being appended</param>
-        protected void SetGlobalFilter(Type type, string jsonString, bool prepend = false)
-        {
-            AddFilter(type, (jsonString, prepend));
-        }
+    /// <summary>
+    /// Specify a global filter to be applied to all operations performed with this DBContext
+    /// </summary>
+    /// <typeparam name="T">The type of Entity this global filter should be applied to</typeparam>
+    /// <param name="filter">b => b.Eq(x => x.Prop1, "some value")</param>
+    /// <param name="prepend">Set to true if you want to prepend this global filter to your operation filters instead of being appended</param>
+    protected void SetGlobalFilter<T>(Func<FilterDefinitionBuilder<T>, FilterDefinition<T>> filter, bool prepend = false) where T : IEntity
+    {
+        SetGlobalFilter(filter(Builders<T>.Filter), prepend);
+    }
+
+    /// <summary>
+    /// Specify a global filter to be applied to all operations performed with this DBContext
+    /// </summary>
+    /// <typeparam name="T">The type of Entity this global filter should be applied to</typeparam>
+    /// <param name="filter">A filter definition to be applied</param>
+    /// <param name="prepend">Set to true if you want to prepend this global filter to your operation filters instead of being appended</param>
+    protected void SetGlobalFilter<T>(FilterDefinition<T> filter, bool prepend = false) where T : IEntity
+    {
+        AddFilter(typeof(T), (filter, prepend));
+    }
 
+    /// <summary>
+    /// Specify a global filter to be applied to all operations performed with this DBContext
+    /// </summary>
+    /// <param name="type">The type of Entity this global filter should be applied to</param>
+    /// <param name="jsonString">A JSON string filter definition to be applied</param>
+    /// <param name="prepend">Set to true if you want to prepend this global filter to your operation filters instead of being appended</param>
+    protected void SetGlobalFilter(Type type, string jsonString, bool prepend = false)
+    {
+        AddFilter(type, (jsonString, prepend));
+    }
 
 
-        /// <summary>
-        /// Specify a global filter to be applied to all operations performed with this DBContext
-        /// </summary>
-        /// <typeparam name="TBase">The type of the base class</typeparam>
-        /// <param name="filter">b => b.Eq(x => x.Prop1, "some value")</param>
-        /// <param name="prepend">Set to true if you want to prepend this global filter to your operation filters instead of being appended</param>
-        protected void SetGlobalFilterForBaseClass<TBase>(Expression<Func<TBase, bool>> filter, bool prepend = false) where TBase : IEntity
-        {
-            SetGlobalFilterForBaseClass(Builders<TBase>.Filter.Where(filter), prepend);
-        }
 
-        /// <summary>
-        /// Specify a global filter to be applied to all operations performed with this DBContext
-        /// </summary>
-        /// <typeparam name="TBase">The type of the base class</typeparam>
-        /// <param name="filter">b => b.Eq(x => x.Prop1, "some value")</param>
-        /// <param name="prepend">Set to true if you want to prepend this global filter to your operation filters instead of being appended</param>
-        protected void SetGlobalFilterForBaseClass<TBase>(Func<FilterDefinitionBuilder<TBase>, FilterDefinition<TBase>> filter, bool prepend = false) where TBase : IEntity
-        {
-            SetGlobalFilterForBaseClass(filter(Builders<TBase>.Filter), prepend);
-        }
+    /// <summary>
+    /// Specify a global filter to be applied to all operations performed with this DBContext
+    /// </summary>
+    /// <typeparam name="TBase">The type of the base class</typeparam>
+    /// <param name="filter">b => b.Eq(x => x.Prop1, "some value")</param>
+    /// <param name="prepend">Set to true if you want to prepend this global filter to your operation filters instead of being appended</param>
+    protected void SetGlobalFilterForBaseClass<TBase>(Expression<Func<TBase, bool>> filter, bool prepend = false) where TBase : IEntity
+    {
+        SetGlobalFilterForBaseClass(Builders<TBase>.Filter.Where(filter), prepend);
+    }
+
+    /// <summary>
+    /// Specify a global filter to be applied to all operations performed with this DBContext
+    /// </summary>
+    /// <typeparam name="TBase">The type of the base class</typeparam>
+    /// <param name="filter">b => b.Eq(x => x.Prop1, "some value")</param>
+    /// <param name="prepend">Set to true if you want to prepend this global filter to your operation filters instead of being appended</param>
+    protected void SetGlobalFilterForBaseClass<TBase>(Func<FilterDefinitionBuilder<TBase>, FilterDefinition<TBase>> filter, bool prepend = false) where TBase : IEntity
+    {
+        SetGlobalFilterForBaseClass(filter(Builders<TBase>.Filter), prepend);
+    }
 
-        /// <summary>
-        /// Specify a global filter to be applied to all operations performed with this DBContext
-        /// </summary>
-        /// <typeparam name="TBase">The type of the base class</typeparam>
-        /// <param name="filter">A filter definition to be applied</param>
-        /// <param name="prepend">Set to true if you want to prepend this global filter to your operation filters instead of being appended</param>
-        protected void SetGlobalFilterForBaseClass<TBase>(FilterDefinition<TBase> filter, bool prepend = false) where TBase : IEntity
+    /// <summary>
+    /// Specify a global filter to be applied to all operations performed with this DBContext
+    /// </summary>
+    /// <typeparam name="TBase">The type of the base class</typeparam>
+    /// <param name="filter">A filter definition to be applied</param>
+    /// <param name="prepend">Set to true if you want to prepend this global filter to your operation filters instead of being appended</param>
+    protected void SetGlobalFilterForBaseClass<TBase>(FilterDefinition<TBase> filter, bool prepend = false) where TBase : IEntity
+    {
+        foreach (var entType in MongoServerContext.AllEntitiyTypes.Where(t => t.IsSubclassOf(typeof(TBase))))
         {
-            foreach (var entType in MongoServerContext.AllEntitiyTypes.Where(t => t.IsSubclassOf(typeof(TBase))))
-            {
-                var bsonDoc = filter.Render(
-                    BsonSerializer.SerializerRegistry.GetSerializer<TBase>(),
-                    BsonSerializer.SerializerRegistry);
+            var bsonDoc = filter.Render(
+                BsonSerializer.SerializerRegistry.GetSerializer<TBase>(),
+                BsonSerializer.SerializerRegistry);
 
-                AddFilter(entType, (bsonDoc, prepend));
-            }
+            AddFilter(entType, (bsonDoc, prepend));
         }
+    }
 
-        /// <summary>
-        /// Specify a global filter for all entity types that implements a given interface
-        /// </summary>
-        /// <typeparam name="TInterface">The interface type to target. Will throw if supplied argument is not an interface type</typeparam>
-        /// <param name="jsonString">A JSON string filter definition to be applied</param>
-        /// <param name="prepend">Set to true if you want to prepend this global filter to your operation filters instead of being appended</param>
-        protected void SetGlobalFilterForInterface<TInterface>(string jsonString, bool prepend = false)
-        {
-            var targetType = typeof(TInterface);
+    /// <summary>
+    /// Specify a global filter for all entity types that implements a given interface
+    /// </summary>
+    /// <typeparam name="TInterface">The interface type to target. Will throw if supplied argument is not an interface type</typeparam>
+    /// <param name="jsonString">A JSON string filter definition to be applied</param>
+    /// <param name="prepend">Set to true if you want to prepend this global filter to your operation filters instead of being appended</param>
+    protected void SetGlobalFilterForInterface<TInterface>(string jsonString, bool prepend = false)
+    {
+        var targetType = typeof(TInterface);
 
-            if (!targetType.IsInterface) throw new ArgumentException("Only interfaces are allowed!", "TInterface");
+        if (!targetType.IsInterface) throw new ArgumentException("Only interfaces are allowed!", "TInterface");
 
 
-            foreach (var entType in MongoServerContext.AllEntitiyTypes.Where(t => targetType.IsAssignableFrom(t)))
-            {
-                AddFilter(entType, (jsonString, prepend));
-            }
+        foreach (var entType in MongoServerContext.AllEntitiyTypes.Where(t => targetType.IsAssignableFrom(t)))
+        {
+            AddFilter(entType, (jsonString, prepend));
         }
+    }
 
 
 
 
-        private void ThrowIfModifiedByIsEmpty<T>() where T : IEntity
+    private void ThrowIfModifiedByIsEmpty<T>() where T : IEntity
+    {
+        var cache = Cache<T>();
+        if (cache.ModifiedByProp is not null && ModifiedBy is null)
         {
-            if (Cache<T>().ModifiedByProp != null && ModifiedBy is null)
-            {
-                throw new InvalidOperationException(
-                    $"A value for [{Cache<T>().ModifiedByProp.Name}] must be specified when saving/updating entities of type [{Cache<T>().CollectionName}]");
-            }
+            throw new InvalidOperationException(
+                $"A value for [{cache.ModifiedByProp.Name}] must be specified when saving/updating entities of type [{cache.CollectionName}]");
         }
+    }
 
-        private void AddFilter(Type type, (object filterDef, bool prepend) filter)
-        {
-            GlobalFilters[type] = filter;
-        }
+    private void AddFilter(Type type, (object filterDef, bool prepend) filter)
+    {
+        GlobalFilters[type] = filter;
+    }
 
 
-        private readonly ConcurrentDictionary<Type, Cache> _cache = new();
-        internal Cache<T> Cache<T>() where T : IEntity
+    private readonly ConcurrentDictionary<Type, Cache> _cache = new();
+    internal EntityCache<T> Cache<T>() where T : IEntity
+    {
+        if (!_cache.TryGetValue(typeof(T), out var c))
         {
-            if (!_cache.TryGetValue(typeof(T), out var c))
-            {
-                c = new Cache<T>();
-            }
-            return (Cache<T>)c;
+            c = new EntityCache<T>();
         }
-        public virtual string CollectionNameFor<T>() where T : IEntity
+        return (EntityCache<T>)c;
+    }
+    public virtual string CollectionName<T>() where T : IEntity
+    {
+        return Cache<T>().CollectionName;
+    }
+
+    public virtual IMongoCollection<T> Collection<T>(string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
+    {
+        return collection ?? GetCollection<T>(collectionName ?? CollectionName<T>());
+    }
+
+    public async Task<bool> PingNetwork()
+    {
+        try
         {
-            return Cache<T>().CollectionName;
+            await Database.RunCommandAsync((Command<BsonDocument>)"{ping:1}").ConfigureAwait(false);
+            return true;
         }
-        public virtual IMongoCollection<T> CollectionFor<T>() where T : IEntity
+        catch (Exception)
         {
-            return Database.GetCollection<T>(CollectionNameFor<T>());
+            return false;
         }
+
     }
 }
diff --git a/MongoDB.Entities/DBContext/TenantContext.cs b/MongoDB.Entities/DBContext/TenantContext.cs
deleted file mode 100644
index 82df7a106..000000000
--- a/MongoDB.Entities/DBContext/TenantContext.cs
+++ /dev/null
@@ -1,69 +0,0 @@
-using MongoDB.Driver;
-using System.Threading.Tasks;
-
-namespace MongoDB.Entities
-{
-    /// <summary>
-    /// Use this class as the main entrypoint when using multi-tenancy
-    /// </summary>
-    public class TenantContext : DBContext
-    {
-        /// <summary>
-        /// If you use this ctor, make sure to call SetTenantPrefix() method and specify the tenant prefix
-        /// </summary>
-        public TenantContext() { }
-
-        /// <summary>
-        /// Instantiate a tenant context with the given tenant prefix value.
-        /// </summary>
-        /// <param name="tenantPrefix">The tenant prefix to be prepended to database names</param>
-        public TenantContext(string tenantPrefix)
-        {
-            this.tenantPrefix = tenantPrefix;
-        }
-
-        /// <summary>
-        /// Set the tenant prefix
-        /// </summary>
-        /// <param name="tenantPrefix">The tenant prefix to be prepended to database names</param>
-        public void SetTenantPrefix(string tenantPrefix)
-            => this.tenantPrefix = tenantPrefix;
-
-        /// <summary>
-        /// Configure this tenant context to be able to connect to a particular database/server.
-        /// <para>TIP: network connection is deferred until the first actual operation.</para>
-        /// </summary>
-        /// <param name="dbName">Name of the database (without tenant prefix)</param>
-        /// <param name="host">Address of the MongoDB server</param>
-        /// <param name="port">Port number of the server</param>
-        /// <param name="modifiedBy">An optional ModifiedBy instance. 
-        /// When supplied, all save/update operations performed via this DBContext instance will set the value on entities that has a property of type ModifiedBy. 
-        /// You can even inherit from the ModifiedBy class and add your own properties to it. 
-        /// Only one ModifiedBy property is allowed on a single entity type.</param>
-        public void Init(string dbName, string host = "127.0.0.1", int port = 27017, ModifiedBy modifiedBy = null)
-        {
-            ModifiedBy = modifiedBy;
-            DB.Initialize(
-                new MongoClientSettings { Server = new MongoServerAddress(host, port) },
-                $"{tenantPrefix}~{dbName}",
-                true
-            ).GetAwaiter().GetResult();
-        }
-
-        /// <summary>
-        /// Configure this tenant context to be able to connect to a particular database/server.
-        /// <para>TIP: network connection is deferred until the first actual operation.</para>
-        /// </summary>
-        /// <param name="dbName">Name of the database (without tenant prefix)</param>
-        /// <param name="settings">A MongoClientSettings object</param>
-        /// <param name="modifiedBy">An optional ModifiedBy instance. 
-        /// When supplied, all save/update operations performed via this DBContext instance will set the value on entities that has a property of type ModifiedBy. 
-        /// You can even inherit from the ModifiedBy class and add your own properties to it. 
-        /// Only one ModifiedBy property is allowed on a single entity type.</param>
-        public void Init(string dbName, MongoClientSettings settings, ModifiedBy modifiedBy = null)
-        {
-            ModifiedBy = modifiedBy;
-            DB.Initialize(settings, $"{tenantPrefix}~{dbName}", true).GetAwaiter().GetResult();
-        }
-    }
-}
diff --git a/MongoDB.Entities/MongoContext/MongoContext.IMongoClient.cs b/MongoDB.Entities/MongoContext/MongoContext.IMongoClient.cs
index a3cbe7bfd..bcc830df9 100644
--- a/MongoDB.Entities/MongoContext/MongoContext.IMongoClient.cs
+++ b/MongoDB.Entities/MongoContext/MongoContext.IMongoClient.cs
@@ -36,7 +36,8 @@ Task IMongoClient.DropDatabaseAsync(IClientSessionHandle session, string name, C
             return Client.DropDatabaseAsync(session, name, cancellationToken);
         }
 
-        public IMongoDatabase GetDatabase(string name, MongoDatabaseSettings? settings = null)
+
+        IMongoDatabase IMongoClient.GetDatabase(string name, MongoDatabaseSettings settings)
         {
             return Client.GetDatabase(name, settings);
         }
@@ -146,7 +147,7 @@ Task<IChangeStreamCursor<TResult>> IMongoClient.WatchAsync<TResult>(PipelineDefi
             return Client.WatchAsync(pipeline, options, cancellationToken);
         }
 
-        Task<IChangeStreamCursor<TResult>> IMongoClient.WatchAsync<TResult>(IClientSessionHandle session, PipelineDefinition<ChangeStreamDocument<BsonDocument>, TResult> pipeline, ChangeStreamOptions options, CancellationToken cancellationToken = default)
+        Task<IChangeStreamCursor<TResult>> IMongoClient.WatchAsync<TResult>(IClientSessionHandle session, PipelineDefinition<ChangeStreamDocument<BsonDocument>, TResult> pipeline, ChangeStreamOptions options, CancellationToken cancellationToken)
         {
             return Client.WatchAsync(session, pipeline, options, cancellationToken);
         }
diff --git a/MongoDB.Entities/MongoContext/MongoContext.cs b/MongoDB.Entities/MongoContext/MongoContext.cs
index 6833ff3e6..957afc8a5 100644
--- a/MongoDB.Entities/MongoContext/MongoContext.cs
+++ b/MongoDB.Entities/MongoContext/MongoContext.cs
@@ -23,6 +23,7 @@ public MongoServerContext(IMongoClient client, MongoContextOptions? options = nu
             Options = options ?? new();
         }
 
+
         /// <summary>
         /// The backing client
         /// </summary>
@@ -32,7 +33,10 @@ public MongoServerContext(IMongoClient client, MongoContextOptions? options = nu
 
         /// <inheritdoc cref="MongoContextOptions.ModifiedBy"/>
         public ModifiedBy? ModifiedBy => Options.ModifiedBy;
-
+        public DBContext GetDatabase(string name, MongoDatabaseSettings? settings = null, DBContextOptions? options = null)
+        {
+            return new(this, Client.GetDatabase(name, settings), options);
+        }
         public async Task<List<string>> AllDatabaseNamesAsync()
         {
             return await (await
@@ -43,8 +47,6 @@ public async Task<List<string>> AllDatabaseNamesAsync()
 
         private Type[]? _allEntitiyTypes;
         public Type[] AllEntitiyTypes => _allEntitiyTypes ??= GetAllEntityTypes();
-
-
         private static Type[] GetAllEntityTypes()
         {
             var excludes = new[]
@@ -69,6 +71,11 @@ private static Type[] GetAllEntityTypes()
                 .ToArray();
         }
 
+        //key: entity type
+        //val: database name without tenant prefix (will be null if not specifically set using DB.DatabaseFor<T>() method)
+        internal readonly ConcurrentDictionary<Type, string> _typeToDbName = new();
+        internal void MapTypeToDb<T>(string dbNameWithoutTenantPrefix) where T : IEntity
+           => _typeToDbName[typeof(T)] = dbNameWithoutTenantPrefix;
     }
 
 }
diff --git a/MongoDB.Entities/MongoDB.Entities.csproj b/MongoDB.Entities/MongoDB.Entities.csproj
index a6002511a..fe0c9639b 100644
--- a/MongoDB.Entities/MongoDB.Entities.csproj
+++ b/MongoDB.Entities/MongoDB.Entities.csproj
@@ -27,7 +27,7 @@
 		<PackageReadmeFile>README.md</PackageReadmeFile>
 		<PackageTags>mongodb mongodb-orm mongodb-repo mongodb-repository entities nosql orm linq netcore repository aspnetcore netcore2 netcore3 dotnetstandard database persistance dal repo</PackageTags>
 		<GenerateDocumentationFile>true</GenerateDocumentationFile>
-		<LangVersion>9.0</LangVersion>
+		<LangVersion>latest</LangVersion>
 	</PropertyGroup>
 
 	<PropertyGroup>
diff --git a/MongoDB.Entities/Relationships/JoinRecord.cs b/MongoDB.Entities/Relationships/JoinRecord.cs
index 6e92f4421..2611c256b 100644
--- a/MongoDB.Entities/Relationships/JoinRecord.cs
+++ b/MongoDB.Entities/Relationships/JoinRecord.cs
@@ -10,12 +10,12 @@ public class JoinRecord : Entity
         /// The ID of the parent IEntity for both one-to-many and the owner side of many-to-many relationships.
         /// </summary>
         [AsObjectId]
-        public string ParentID { get; set; }
+        public string ParentID { get; set; } = null!;
 
         /// <summary>
         /// The ID of the child IEntity in one-to-many relationships and the ID of the inverse side IEntity in many-to-many relationships.
         /// </summary>
         [AsObjectId]
-        public string ChildID { get; set; }
+        public string ChildID { get; set; } = null!;
     }
 }
diff --git a/MongoDB.Entities/Relationships/Many.Remove.cs b/MongoDB.Entities/Relationships/Many.Remove.cs
index 6272727b8..edce4b7de 100644
--- a/MongoDB.Entities/Relationships/Many.Remove.cs
+++ b/MongoDB.Entities/Relationships/Many.Remove.cs
@@ -47,7 +47,7 @@ public Task RemoveAsync(IEnumerable<TChild> children, IClientSessionHandle sessi
         /// <param name="childIDs">The IDs of the child Entities to remove the references of</param>
         /// <param name="session">An optional session if using within a transaction</param>
         /// <param name="cancellation">An optional cancellation token</param>
-        public Task RemoveAsync(IEnumerable<string> childIDs, IClientSessionHandle session = null, CancellationToken cancellation = default)
+        public Task RemoveAsync(IEnumerable<string> childIDs, IClientSessionHandle? session = null, CancellationToken cancellation = default)
         {
             var filter =
                 isInverse

From 2558d59f7883476c722eb21cc4accda003b9130e Mon Sep 17 00:00:00 2001
From: Ahmed Fwela <ahmednfwela@bdaya-dev.com>
Date: Wed, 10 Nov 2021 13:34:02 +0200
Subject: [PATCH 16/26] Moved transaction logic to MongoServerContext

---
 .../DBContext/DBContext.Transaction.cs        | 24 +-------
 MongoDB.Entities/DBContext/DBContext.cs       |  4 +-
 MongoDB.Entities/MongoContext/MongoContext.cs | 56 +++++++++++++++++++
 3 files changed, 61 insertions(+), 23 deletions(-)

diff --git a/MongoDB.Entities/DBContext/DBContext.Transaction.cs b/MongoDB.Entities/DBContext/DBContext.Transaction.cs
index 9cfda4bcc..daca1bd55 100644
--- a/MongoDB.Entities/DBContext/DBContext.Transaction.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Transaction.cs
@@ -16,15 +16,7 @@ public partial class DBContext
         /// <param name="options">Client session options for this transaction</param>
         public IClientSessionHandle Transaction(ClientSessionOptions? options = null)
         {
-            if (Session is null)
-            {
-                Session = Client.StartSession(options);
-                Session.StartTransaction();
-                return Session;
-            }
-
-            throw new NotSupportedException(
-                "Only one transaction is allowed per DBContext instance. Dispose and nullify the Session before calling this method again!");
+            return MongoServerContext.Transaction(options);
         }
 
 
@@ -34,12 +26,7 @@ public IClientSessionHandle Transaction(ClientSessionOptions? options = null)
         /// <param name="cancellation">An optional cancellation token</param>
         public Task CommitAsync(CancellationToken cancellation = default)
         {
-            if (Session is null)
-            {
-                throw new ArgumentNullException(nameof(Session), "Please call Transaction<T>() first before committing");
-            }
-
-            return Session.CommitTransactionAsync(cancellation);
+            return MongoServerContext.CommitAsync(cancellation);
         }
 
         /// <summary>
@@ -48,12 +35,7 @@ public Task CommitAsync(CancellationToken cancellation = default)
         /// <param name="cancellation">An optional cancellation token</param>
         public Task AbortAsync(CancellationToken cancellation = default)
         {
-            if (Session is null)
-            {
-                throw new ArgumentNullException(nameof(Session), "Please call Transaction<T>() first before aborting");
-            }
-
-            return Session.AbortTransactionAsync(cancellation);
+            return MongoServerContext.AbortAsync(cancellation);
         }
     }
 }
diff --git a/MongoDB.Entities/DBContext/DBContext.cs b/MongoDB.Entities/DBContext/DBContext.cs
index 28f618cf8..fb2bd1e61 100644
--- a/MongoDB.Entities/DBContext/DBContext.cs
+++ b/MongoDB.Entities/DBContext/DBContext.cs
@@ -19,9 +19,9 @@ namespace MongoDB.Entities;
 public partial class DBContext : IMongoDatabase
 {
     /// <summary>
-    /// Returns the session object used for transactions
+    /// Returns the session object used for transactions <see cref="MongoServerContext.Session"/>
     /// </summary>
-    public IClientSessionHandle? Session { get; protected set; }
+    public IClientSessionHandle? Session => MongoServerContext.Session;
 
 
     public MongoServerContext MongoServerContext { get; }
diff --git a/MongoDB.Entities/MongoContext/MongoContext.cs b/MongoDB.Entities/MongoContext/MongoContext.cs
index 957afc8a5..571608d45 100644
--- a/MongoDB.Entities/MongoContext/MongoContext.cs
+++ b/MongoDB.Entities/MongoContext/MongoContext.cs
@@ -3,6 +3,7 @@
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
 #nullable enable
 namespace MongoDB.Entities
@@ -76,6 +77,61 @@ private static Type[] GetAllEntityTypes()
         internal readonly ConcurrentDictionary<Type, string> _typeToDbName = new();
         internal void MapTypeToDb<T>(string dbNameWithoutTenantPrefix) where T : IEntity
            => _typeToDbName[typeof(T)] = dbNameWithoutTenantPrefix;
+
+
+        /// <summary>
+        /// Returns the session object used for transactions
+        /// </summary>
+        public IClientSessionHandle? Session { get; protected set; }
+
+        /// <summary>
+        /// Starts a transaction and returns a session object.
+        /// <para>WARNING: Only one transaction is allowed per DBContext instance. 
+        /// Call Session.Dispose() and assign a null to it before calling this method a second time. 
+        /// Trying to start a second transaction for this DBContext instance will throw an exception.</para>
+        /// </summary>
+        /// <param name="options">Client session options for this transaction</param>
+        public IClientSessionHandle Transaction(ClientSessionOptions? options = null)
+        {
+            if (Session is null)
+            {
+                Session = Client.StartSession(options);
+                Session.StartTransaction();
+                return Session;
+            }
+
+            throw new NotSupportedException(
+                "Only one transaction is allowed per DBContext instance. Dispose and nullify the Session before calling this method again!");
+        }
+
+
+        /// <summary>
+        /// Commits a transaction to MongoDB
+        /// </summary>
+        /// <param name="cancellation">An optional cancellation token</param>
+        public Task CommitAsync(CancellationToken cancellation = default)
+        {
+            if (Session is null)
+            {
+                throw new ArgumentNullException(nameof(Session), "Please call Transaction<T>() first before committing");
+            }
+
+            return Session.CommitTransactionAsync(cancellation);
+        }
+
+        /// <summary>
+        /// Aborts and rolls back a transaction
+        /// </summary>
+        /// <param name="cancellation">An optional cancellation token</param>
+        public Task AbortAsync(CancellationToken cancellation = default)
+        {
+            if (Session is null)
+            {
+                throw new ArgumentNullException(nameof(Session), "Please call Transaction<T>() first before aborting");
+            }
+
+            return Session.AbortTransactionAsync(cancellation);
+        }
     }
 
 }

From b42c201405be9b776ca59b4d05ec024b4ce1b4c4 Mon Sep 17 00:00:00 2001
From: Ahmed Fwela <ahmednfwela@bdaya-dev.com>
Date: Wed, 10 Nov 2021 13:42:47 +0200
Subject: [PATCH 17/26] Improved transactions

---
 .../DBContext/DBContext.Transaction.cs        | 10 ++++++
 MongoDB.Entities/DBContext/DBContext.cs       |  1 +
 MongoDB.Entities/MongoContext/MongoContext.cs | 31 +++++++++++++++++--
 3 files changed, 40 insertions(+), 2 deletions(-)

diff --git a/MongoDB.Entities/DBContext/DBContext.Transaction.cs b/MongoDB.Entities/DBContext/DBContext.Transaction.cs
index daca1bd55..ed40c8710 100644
--- a/MongoDB.Entities/DBContext/DBContext.Transaction.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Transaction.cs
@@ -19,6 +19,16 @@ public IClientSessionHandle Transaction(ClientSessionOptions? options = null)
             return MongoServerContext.Transaction(options);
         }
 
+        /// <summary>
+        /// Creates a new DBContext and a new MongoServerContext and Starts a transaction on the new instance.        
+        /// </summary>
+        /// <param name="options">Client session options for this transaction</param>
+        public DBContext TransactionCopy(ClientSessionOptions? options = null)
+        {
+            var server = new MongoServerContext(MongoServerContext);
+            server.Transaction(options);
+            return new DBContext(server, Database, Options);
+        }
 
         /// <summary>
         /// Commits a transaction to MongoDB
diff --git a/MongoDB.Entities/DBContext/DBContext.cs b/MongoDB.Entities/DBContext/DBContext.cs
index fb2bd1e61..9a428e96e 100644
--- a/MongoDB.Entities/DBContext/DBContext.cs
+++ b/MongoDB.Entities/DBContext/DBContext.cs
@@ -341,4 +341,5 @@ public async Task<bool> PingNetwork()
         }
 
     }
+
 }
diff --git a/MongoDB.Entities/MongoContext/MongoContext.cs b/MongoDB.Entities/MongoContext/MongoContext.cs
index 571608d45..71fb87390 100644
--- a/MongoDB.Entities/MongoContext/MongoContext.cs
+++ b/MongoDB.Entities/MongoContext/MongoContext.cs
@@ -11,10 +11,10 @@ namespace MongoDB.Entities
     /// <summary>
     /// MongoContext is a wrapper around an <see cref="IMongoClient"/>
     /// </summary>
-    public partial class MongoServerContext : IMongoClient
+    public partial class MongoServerContext : IMongoClient, IDisposable
     {
         /// <summary>
-        /// Creates a new context
+        /// Creates a new server context
         /// </summary>        
         /// <param name="client">The backing client, usually a <see cref="MongoClient"/></param>
         /// <param name="options">The options to configure the context</param>
@@ -24,6 +24,16 @@ public MongoServerContext(IMongoClient client, MongoContextOptions? options = nu
             Options = options ?? new();
         }
 
+        /// <summary>
+        /// Copies a new MongoServerContext without the Session
+        /// </summary>        
+        /// <param name="other"></param>
+        public MongoServerContext(MongoServerContext other)
+        {
+            Client = other.Client;
+            Options = other.Options;
+        }
+
 
         /// <summary>
         /// The backing client
@@ -104,6 +114,17 @@ public IClientSessionHandle Transaction(ClientSessionOptions? options = null)
                 "Only one transaction is allowed per DBContext instance. Dispose and nullify the Session before calling this method again!");
         }
 
+        /// <summary>
+        /// Creates a new MongoServerContext and Starts a transaction on the new instance.        
+        /// </summary>
+        /// <param name="options">Client session options for this transaction</param>
+        public MongoServerContext TransactionCopy(ClientSessionOptions? options = null)
+        {
+            var res = new MongoServerContext(this);
+            res.Transaction(options);
+            return res;
+        }
+
 
         /// <summary>
         /// Commits a transaction to MongoDB
@@ -132,6 +153,12 @@ public Task AbortAsync(CancellationToken cancellation = default)
 
             return Session.AbortTransactionAsync(cancellation);
         }
+
+        public void Dispose()
+        {
+            Session?.Dispose();
+            Session = null;
+        }
     }
 
 }

From 93e38248581a7eb322656dbd4d46bb3fb9272931 Mon Sep 17 00:00:00 2001
From: Ahmed Fwela <ahmednfwela@bdaya-dev.com>
Date: Wed, 10 Nov 2021 14:27:33 +0200
Subject: [PATCH 18/26] changed One<T> api

---
 MongoDB.Entities/Core/Entity.cs       |   4 +-
 MongoDB.Entities/Core/IEntity.cs      |   2 +-
 MongoDB.Entities/Extensions/Entity.cs |   2 +-
 MongoDB.Entities/Relationships/One.cs | 130 ++++++++++++++++----------
 4 files changed, 85 insertions(+), 53 deletions(-)

diff --git a/MongoDB.Entities/Core/Entity.cs b/MongoDB.Entities/Core/Entity.cs
index a7b7b5073..614e646fc 100644
--- a/MongoDB.Entities/Core/Entity.cs
+++ b/MongoDB.Entities/Core/Entity.cs
@@ -7,12 +7,12 @@ namespace MongoDB.Entities
     /// Inherit this class for all entities you want to store in their own collection.
     /// </summary>
     public abstract class Entity : IEntity
-    {        
+    {
         /// <summary>
         /// This property is auto managed. A new ID will be assigned for new entities upon saving.
         /// </summary>
         [BsonId, AsObjectId]
-        public string ID { get; set; }
+        public string? ID { get; set; }
 
         /// <summary>
         /// Override this method in order to control the generation of IDs for new entities.
diff --git a/MongoDB.Entities/Core/IEntity.cs b/MongoDB.Entities/Core/IEntity.cs
index 90e799495..5589e08fe 100644
--- a/MongoDB.Entities/Core/IEntity.cs
+++ b/MongoDB.Entities/Core/IEntity.cs
@@ -9,7 +9,7 @@ public interface IEntity
         /// The ID property for this entity type.
         /// <para>IMPORTANT: make sure to decorate this property with the [BsonId] attribute when implementing this interface</para>
         /// </summary>
-        string ID { get; set; }
+        string? ID { get; set; }
 
         /// <summary>
         /// Generate and return a new ID string from this method. It will be used when saving new entities that don't have their ID set. 
diff --git a/MongoDB.Entities/Extensions/Entity.cs b/MongoDB.Entities/Extensions/Entity.cs
index 80e0bf4a6..c0ddf3fb2 100644
--- a/MongoDB.Entities/Extensions/Entity.cs
+++ b/MongoDB.Entities/Extensions/Entity.cs
@@ -30,7 +30,7 @@ private static T Duplicate<T>(this T source)
                 ).Data;
         }
 
-        internal static void ThrowIfUnsaved(this string entityID)
+        internal static void ThrowIfUnsaved(this string? entityID)
         {
             if (string.IsNullOrWhiteSpace(entityID))
                 throw new InvalidOperationException("Please save the entity before performing this operation!");
diff --git a/MongoDB.Entities/Relationships/One.cs b/MongoDB.Entities/Relationships/One.cs
index e6d2f6220..99f4aa7f2 100644
--- a/MongoDB.Entities/Relationships/One.cs
+++ b/MongoDB.Entities/Relationships/One.cs
@@ -13,14 +13,31 @@ namespace MongoDB.Entities
     /// <typeparam name="T">Any type that implements IEntity</typeparam>
     public class One<T> where T : IEntity
     {
+        private T? _cache;
+
         /// <summary>
         /// The Id of the entity referenced by this instance.
         /// </summary>
         [AsObjectId]
-        public string ID { get; set; }
+        public string? ID { get; set; }
+
+        public T? Cache
+        {
+            get => _cache;
+            set
+            {
+                value?.ThrowIfUnsaved();
+                _cache = value;
+                if (ID != value?.ID)
+                {
+                    ID = value?.ID!;
+                }
+            }
+        }
 
         public One()
-        { }
+        {
+        }
 
         /// <summary>
         /// Initializes a reference to an entity in MongoDB.
@@ -28,8 +45,7 @@ public One()
         /// <param name="entity">The actual entity this reference represents.</param>
         internal One(T entity)
         {
-            entity.ThrowIfUnsaved();
-            ID = entity.ID;
+            Cache = entity;
         }
 
         /// <summary>
@@ -38,7 +54,7 @@ internal One(T entity)
         /// <param name="id">The ID to create a new One&lt;T&gt; with</param>
         public static implicit operator One<T>(string id)
         {
-            return new One<T> { ID = id };
+            return new One<T>() { ID = id };
         }
 
         /// <summary>
@@ -50,51 +66,67 @@ public static implicit operator One<T>(T entity)
             return new One<T>(entity);
         }
 
-        //TODO: revamp One/Many api
-        ///// <summary>
-        ///// Fetches the actual entity this reference represents from the database.
-        ///// </summary>
-        ///// <param name="session">An optional session</param>
-        ///// <param name="cancellation">An optional cancellation token</param>
-        ///// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        ///// <returns>A Task containing the actual entity</returns>
-        //public Task<T> ToEntityAsync(IClientSessionHandle session = null, CancellationToken cancellation = default, string tenantPrefix = null)
-        //{
-        //    return new Find<T>(session, null, tenantPrefix).OneAsync(ID, cancellation);
-        //}
+        /// <summary>
+        /// Fetches the actual entity this reference represents from the database.
+        /// </summary>
+        /// <param name="context"></param>
+        /// <param name="cancellation">An optional cancellation token</param>
+        /// <param name="collectionName"></param>
+        /// <param name="collection"></param>
+        /// <returns>A Task containing the actual entity</returns>
+        public async Task<T?> ToEntityAsync(DBContext context, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null)
+        {
+            if (ID is null)
+            {
+                return default;
+            }
+
+            return Cache = await new Find<T>(context, collection ?? context.Collection<T>(collectionName)).OneAsync(ID, cancellation);
+        }
+
+        /// <summary>
+        /// Fetches the actual entity this reference represents from the database with a projection.
+        /// </summary>
+        /// <param name="context"></param>
+        /// <param name="projection">x => new Test { PropName = x.Prop }</param>
+        /// <param name = "cancellation" > An optional cancellation token</param>
+        /// <param name="collectionName"></param>
+        /// <param name="collection"></param>
+        /// <returns>A Task containing the actual projected entity</returns>
+        public async Task<T?> ToEntityAsync<TFrom>(DBContext context, Expression<Func<TFrom, T>> projection, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<TFrom>? collection = null) where TFrom : IEntity
+        {
+            if (ID is null)
+            {
+                return default;
+            }
 
-        ///// <summary>
-        ///// Fetches the actual entity this reference represents from the database with a projection.
-        ///// </summary>
-        ///// <param name="projection">x => new Test { PropName = x.Prop }</param>
-        ///// <param name="session">An optional session if using within a transaction</param>
-        ///// <param name = "cancellation" > An optional cancellation token</param>
-        ///// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        ///// <returns>A Task containing the actual projected entity</returns>
-        //public async Task<T> ToEntityAsync(Expression<Func<T, T>> projection, IClientSessionHandle session = null, CancellationToken cancellation = default, string tenantPrefix = null)
-        //{
-        //    return (await new Find<T>(session, null, tenantPrefix)
-        //                .Match(ID)
-        //                .Project(projection)
-        //                .ExecuteAsync(cancellation).ConfigureAwait(false))
-        //           .SingleOrDefault();
-        //}
+            return Cache = (await new Find<TFrom, T>(context, collection ?? context.Collection<TFrom>(collectionName))
+                        .Match(ID)
+                        .Project(projection)
+                        .ExecuteAsync(cancellation).ConfigureAwait(false))
+                   .SingleOrDefault();
+        }
 
-        ///// <summary>
-        ///// Fetches the actual entity this reference represents from the database with a projection.
-        ///// </summary>
-        ///// <param name="projection">p=> p.Include("Prop1").Exclude("Prop2")</param>
-        ///// <param name="session">An optional session if using within a transaction</param>
-        ///// <param name = "cancellation" > An optional cancellation token</param>
-        ///// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        ///// <returns>A Task containing the actual projected entity</returns>
-        //public async Task<T> ToEntityAsync(Func<ProjectionDefinitionBuilder<T>, ProjectionDefinition<T, T>> projection, IClientSessionHandle session = null, CancellationToken cancellation = default, string tenantPrefix = null)
-        //{
-        //    return (await new Find<T>(session, null, tenantPrefix)
-        //                .Match(ID)
-        //                .Project(projection)
-        //                .ExecuteAsync(cancellation).ConfigureAwait(false))
-        //           .SingleOrDefault();
-        //}
+        /// <summary>
+        /// Fetches the actual entity this reference represents from the database with a projection.
+        /// </summary>
+        /// <param name="context"></param>
+        /// <param name="projection">p=> p.Include("Prop1").Exclude("Prop2")</param>
+        /// <param name = "cancellation" > An optional cancellation token</param>
+        /// <param name="collectionName"></param>
+        /// <param name="collection"></param>
+        /// <returns>A Task containing the actual projected entity</returns>
+        public async Task<T?> ToEntityAsync<TFrom>(DBContext context, Func<ProjectionDefinitionBuilder<TFrom>, ProjectionDefinition<TFrom, T>> projection, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<TFrom>? collection = null) where TFrom : IEntity
+        {
+            if (ID is null)
+            {
+                return default;
+            }
+            return Cache = (await new Find<TFrom, T>(context, collection ?? context.Collection<TFrom>(collectionName))
+                        .Match(ID)
+                        .Project(projection)
+                        .ExecuteAsync(cancellation).ConfigureAwait(false))
+                   .SingleOrDefault();
+        }
     }
 }

From a30b9be6691fd9d14e2cac9aa5bb1ef73839050e Mon Sep 17 00:00:00 2001
From: Ahmed Fwela <ahmednfwela@bdaya-dev.com>
Date: Wed, 10 Nov 2021 22:52:12 +0200
Subject: [PATCH 19/26] WIP relation support

---
 MongoDB.Entities/Builders/UpdateAndGet.cs     |   5 +-
 MongoDB.Entities/DB/DB.Update.cs              |  18 +-
 .../DBContext/DBContext.Update.cs             |   2 +-
 MongoDB.Entities/Extensions/Database.cs       |  87 +++---
 MongoDB.Entities/Relationships/Many.cs        | 274 +++++++++---------
 MongoDB.Entities/Relationships/NewMany.cs     | 179 ++++++++++++
 6 files changed, 368 insertions(+), 197 deletions(-)
 create mode 100644 MongoDB.Entities/Relationships/NewMany.cs

diff --git a/MongoDB.Entities/Builders/UpdateAndGet.cs b/MongoDB.Entities/Builders/UpdateAndGet.cs
index 26ec002e6..63ce7e30a 100644
--- a/MongoDB.Entities/Builders/UpdateAndGet.cs
+++ b/MongoDB.Entities/Builders/UpdateAndGet.cs
@@ -36,7 +36,7 @@ public class UpdateAndGet<T, TProjection> : UpdateBase<T, UpdateAndGet<T, TProje
         private readonly List<PipelineStageDefinition<T, TProjection>> _stages = new();
         private protected readonly FindOneAndUpdateOptions<T, TProjection> _options = new() { ReturnDocument = ReturnDocument.After };
 
-        public DBContext Context { get; }
+        public override DBContext Context { get; }
         public IMongoCollection<T> Collection { get; }
 
         internal UpdateAndGet(DBContext context, IMongoCollection<T> collection, UpdateBase<T, UpdateAndGet<T, TProjection>> other) : base(other)
@@ -51,8 +51,7 @@ internal UpdateAndGet(DBContext context, IMongoCollection<T> collection, Action<
             Collection = collection;
         }
 
-        private EntityCache<T>? _cache;
-        internal override EntityCache<T> Cache() => _cache ??= Context.Cache<T>();
+
 
         /// <summary>
         /// Specify an update pipeline with multiple stages using a Template to modify the Entities.
diff --git a/MongoDB.Entities/DB/DB.Update.cs b/MongoDB.Entities/DB/DB.Update.cs
index a0aeaa63a..06570c5fe 100644
--- a/MongoDB.Entities/DB/DB.Update.cs
+++ b/MongoDB.Entities/DB/DB.Update.cs
@@ -9,10 +9,8 @@ public static partial class DB
         /// <para>TIP: Specify a filter first with the .Match() method. Then set property values with .Modify() and finally call .Execute() to run the command.</para>
         /// </summary>
         /// <typeparam name="T">Any class that implements IEntity</typeparam>
-        /// <param name="session">An optional session if using within a transaction</param>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static Update<T> Update<T>(IClientSessionHandle session = null, string tenantPrefix = null) where T : IEntity
-            => new(session, null, null, tenantPrefix);
+        public static Update<T> Update<T>() where T : IEntity
+            => Context.Update<T>();
 
         /// <summary>
         /// Update and retrieve the first document that was updated.
@@ -20,19 +18,15 @@ public static Update<T> Update<T>(IClientSessionHandle session = null, string te
         /// </summary>
         /// <typeparam name="T">Any class that implements IEntity</typeparam>
         /// <typeparam name="TProjection">The type to project to</typeparam>
-        /// <param name="session">An optional session if using within a transaction</param>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static UpdateAndGet<T, TProjection> UpdateAndGet<T, TProjection>(IClientSessionHandle session = null, string tenantPrefix = null) where T : IEntity
-            => new(session, null, null, tenantPrefix);
+        public static UpdateAndGet<T, TProjection> UpdateAndGet<T, TProjection>() where T : IEntity
+            => Context.UpdateAndGet<T, TProjection>();
 
         /// <summary>
         /// Update and retrieve the first document that was updated.
         /// <para>TIP: Specify a filter first with the .Match(). Then set property values with .Modify() and finally call .Execute() to run the command.</para>
         /// </summary>
         /// <typeparam name="T">Any class that implements IEntity</typeparam>
-        /// <param name="session">An optional session if using within a transaction</param>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static UpdateAndGet<T> UpdateAndGet<T>(IClientSessionHandle session = null, string tenantPrefix = null) where T : IEntity
-            => new(session, null, null, tenantPrefix);
+        public static UpdateAndGet<T> UpdateAndGet<T>() where T : IEntity
+            => Context.UpdateAndGet<T>();
     }
 }
diff --git a/MongoDB.Entities/DBContext/DBContext.Update.cs b/MongoDB.Entities/DBContext/DBContext.Update.cs
index f38e78087..1e0bc984e 100644
--- a/MongoDB.Entities/DBContext/DBContext.Update.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Update.cs
@@ -24,7 +24,7 @@ public Update<T> Update<T>(string? collectionName = null, IMongoCollection<T>? c
         /// Starts an update-and-get command for the given entity type
         /// </summary>
         /// <typeparam name="T">The type of entity</typeparam>
-        public UpdateAndGet<T, T> UpdateAndGet<T>(string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
+        public UpdateAndGet<T> UpdateAndGet<T>(string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
         {
             return UpdateAndGet<T, T>(collectionName, collection);
         }
diff --git a/MongoDB.Entities/Extensions/Database.cs b/MongoDB.Entities/Extensions/Database.cs
index 331ba7197..6e3883e03 100644
--- a/MongoDB.Entities/Extensions/Database.cs
+++ b/MongoDB.Entities/Extensions/Database.cs
@@ -4,58 +4,57 @@
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace MongoDB.Entities
+namespace MongoDB.Entities;
+
+public static partial class Extensions
 {
-    public static partial class Extensions
-    {
-        /// <summary>
-        /// Gets the IMongoDatabase for the given entity type
-        /// </summary>
-        /// <typeparam name="T">The type of entity</typeparam>
-        public static IMongoDatabase Database<T>(this T _, string tenantPrefix) where T : IEntity => DB.Database<T>(tenantPrefix);
+    /// <summary>
+    /// Gets the IMongoDatabase for the given entity type
+    /// </summary>
+    /// <typeparam name="T">The type of entity</typeparam>
+    [Obsolete("This method returns the current Context", error: true)]
+    public static IMongoDatabase Database<T>(this T _, string tenantPrefix) where T : IEntity => DB.Database<T>();
 
-        /// <summary>
-        /// Gets the name of the database this entity is attached to. Returns name of default database if not specifically attached.
-        /// </summary>
-        public static string DatabaseName<T>(this T _, string tenantPrefix) where T : IEntity => DB.DatabaseName<T>(tenantPrefix);
+    /// <summary>
+    /// Gets the name of the database this entity is attached to. Returns name of default database if not specifically attached.
+    /// </summary>
+    [Obsolete("This method returns the current DatabaseName in the Context")]
+    public static string DatabaseName<T>(this T _, string tenantPrefix) where T : IEntity => DB.DatabaseName<T>();
 
-        /// <summary>
-        /// Pings the mongodb server to check if it's still connectable
-        /// </summary>
-        /// <param name="timeoutSeconds">The number of seconds to keep trying</param>
-        public static async Task<bool> IsAccessibleAsync(this IMongoDatabase db, int timeoutSeconds = 5)
+    /// <summary>
+    /// Pings the mongodb server to check if it's still connectable
+    /// </summary>
+    /// <param name="timeoutSeconds">The number of seconds to keep trying</param>
+    public static async Task<bool> IsAccessibleAsync(this IMongoDatabase db, int timeoutSeconds = 5)
+    {
+        using var cts = new CancellationTokenSource(timeoutSeconds * 1000);
+        try
         {
-            using (var cts = new CancellationTokenSource(timeoutSeconds * 1000))
-            {
-                try
-                {
-                    var res = await db.RunCommandAsync((Command<BsonDocument>)"{ping:1}", null, cts.Token).ConfigureAwait(false);
-                    return res["ok"] == 1;
-                }
-                catch (Exception)
-                {
-                    return false;
-                }
-            }
+            var res = await db.RunCommandAsync((Command<BsonDocument>)"{ping:1}", null, cts.Token).ConfigureAwait(false);
+            return res["ok"] == 1;
         }
+        catch (Exception)
+        {
+            return false;
+        }
+    }
 
-        /// <summary>
-        /// Checks to see if the database already exists on the mongodb server
-        /// </summary>
-        /// <param name="timeoutSeconds">The number of seconds to keep trying</param>
-        public static async Task<bool> ExistsAsync(this IMongoDatabase db, int timeoutSeconds = 5)
+    /// <summary>
+    /// Checks to see if the database already exists on the mongodb server
+    /// </summary>
+    /// <param name="timeoutSeconds">The number of seconds to keep trying</param>
+    public static async Task<bool> ExistsAsync(this IMongoDatabase db, int timeoutSeconds = 5)
+    {
+        using (var cts = new CancellationTokenSource(timeoutSeconds * 1000))
         {
-            using (var cts = new CancellationTokenSource(timeoutSeconds * 1000))
+            try
+            {
+                var dbs = await (await db.Client.ListDatabaseNamesAsync(cts.Token).ConfigureAwait(false)).ToListAsync().ConfigureAwait(false);
+                return dbs.Contains(db.DatabaseNamespace.DatabaseName);
+            }
+            catch (Exception)
             {
-                try
-                {
-                    var dbs = await (await db.Client.ListDatabaseNamesAsync(cts.Token).ConfigureAwait(false)).ToListAsync().ConfigureAwait(false);
-                    return dbs.Contains(db.DatabaseNamespace.DatabaseName);
-                }
-                catch (Exception)
-                {
-                    return false;
-                }
+                return false;
             }
         }
     }
diff --git a/MongoDB.Entities/Relationships/Many.cs b/MongoDB.Entities/Relationships/Many.cs
index 4b5f4a2da..ee5493d96 100644
--- a/MongoDB.Entities/Relationships/Many.cs
+++ b/MongoDB.Entities/Relationships/Many.cs
@@ -6,143 +6,144 @@
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace MongoDB.Entities
-{
+namespace MongoDB.Entities;
+
+/// <summary>
+/// Base class providing shared state for Many'1 classes
+/// </summary>
+public abstract class ManyBase
+{
+    //shared state for all Many<T> instances
+    internal static ConcurrentBag<string> indexedCollections = new();
+    internal static string PropTypeName = typeof(Many<Entity>).Name;
+}
+
+/// <summary>
+/// Represents a one-to-many/many-to-many relationship between two Entities.
+/// <para>WARNING: You have to initialize all instances of this class before accessing any of it's members.</para>
+/// <para>Initialize from the constructor of the parent entity as follows:</para>
+/// <para><c>this.InitOneToMany(() => Property);</c></para>
+/// <para><c>this.InitManyToMany(() => Property, x => x.OtherProperty);</c></para>
+/// </summary>
+/// <see cref="JoinRecord"/>
+/// <typeparam name="TChild">Type of the child IEntity.</typeparam>
+public sealed partial class Many<TChild> : ManyBase where TChild : IEntity
+{
+    private static readonly BulkWriteOptions unOrdBlkOpts = new() { IsOrdered = false };
+    private bool isInverse;
+    private IEntity? parent;
+
     /// <summary>
-    /// Base class providing shared state for Many'1 classes
+    /// Gets the IMongoCollection of JoinRecords for this relationship.
+    /// <para>TIP: Try never to use this unless really neccessary.</para>
     /// </summary>
-    public abstract class ManyBase
-    {
-        //shared state for all Many<T> instances
-        internal static ConcurrentBag<string> indexedCollections = new();
-        internal static string PropTypeName = typeof(Many<Entity>).Name;
-    }
+    //public IMongoCollection<JoinRecord> JoinCollection { get; private set; }
+
+    public string TargetCollectionName { get; set; }
 
     /// <summary>
-    /// Represents a one-to-many/many-to-many relationship between two Entities.
-    /// <para>WARNING: You have to initialize all instances of this class before accessing any of it's members.</para>
-    /// <para>Initialize from the constructor of the parent entity as follows:</para>
-    /// <para><c>this.InitOneToMany(() => Property);</c></para>
-    /// <para><c>this.InitManyToMany(() => Property, x => x.OtherProperty);</c></para>
+    /// Get the number of children for a relationship
     /// </summary>
-    /// <typeparam name="TChild">Type of the child IEntity.</typeparam>
-    public sealed partial class Many<TChild> : ManyBase where TChild : IEntity
-    {
-        private static readonly BulkWriteOptions unOrdBlkOpts = new() { IsOrdered = false };
-        private bool isInverse;
-        private IEntity parent;
-
-        /// <summary>
-        /// Gets the IMongoCollection of JoinRecords for this relationship.
-        /// <para>TIP: Try never to use this unless really neccessary.</para>
-        /// </summary>
-        public IMongoCollection<JoinRecord> JoinCollection { get; private set; }
-
-        public string TargetCollectionName { get; set; }
-
-        /// <summary>
-        /// Get the number of children for a relationship
-        /// </summary>
-        /// <param name="session">An optional session if using within a transaction</param>
-        /// <param name="options">An optional AggregateOptions object</param>
-        /// <param name="cancellation">An optional cancellation token</param>
-        public Task<long> ChildrenCountAsync(IClientSessionHandle session = null, CountOptions options = null, CancellationToken cancellation = default)
-        {
-            parent.ThrowIfUnsaved();
-
-            if (isInverse)
-            {
-                return session == null
-                       ? JoinCollection.CountDocumentsAsync(j => j.ChildID == parent.ID, options, cancellation)
-                       : JoinCollection.CountDocumentsAsync(session, j => j.ChildID == parent.ID, options, cancellation);
-            }
-            else
-            {
-                return session == null
-                       ? JoinCollection.CountDocumentsAsync(j => j.ParentID == parent.ID, options, cancellation)
-                       : JoinCollection.CountDocumentsAsync(session, j => j.ParentID == parent.ID, options, cancellation);
-            }
-        }
-
-        /// <summary>
-        /// Creates an instance of Many&lt;TChild&gt; 
-        /// This is only needed in VB.Net
-        /// </summary>
-        public Many() { }
-
-        #region one-to-many-initializers
-        internal Many(object parent, string property)
-        {
-            Init((dynamic)parent, property);
-        }
-
-        private void Init<TParent>(TParent parent, string property) where TParent : IEntity
-        {
-            if (DB.DatabaseName<TParent>(null) != DB.DatabaseName<TChild>(null))
-                throw new NotSupportedException("Cross database relationships are not supported!");
-
-            this.parent = parent;
-            isInverse = false;
-            JoinCollection = DB.GetRefCollection<TParent>($"[{DB.CollectionName<TParent>()}~{DB.CollectionName<TChild>()}({property})]");
-            CreateIndexesAsync(JoinCollection);
-        }
-
-        /// <summary>
-        /// Use this method to initialize the Many&lt;TChild&gt; properties with VB.Net
-        /// </summary>
-        /// <typeparam name="TParent">The type of the parent</typeparam>
-        /// <param name="parent">The parent entity instance</param>
-        /// <param name="property">Function(x) x.PropName</param>
-        public void VB_InitOneToMany<TParent>(TParent parent, Expression<Func<TParent, object>> property) where TParent : IEntity
-        {
-            Init(parent, Prop.Property(property));
-        }
-        #endregion
-
-        #region many-to-many initializers
-        internal Many(object parent, string propertyParent, string propertyChild, bool isInverse)
-        {
-            Init((dynamic)parent, propertyParent, propertyChild, isInverse);
-        }
-
-        private void Init<TParent>(TParent parent, string propertyParent, string propertyChild, bool isInverse) where TParent : IEntity
-        {
-            this.parent = parent;
-            this.isInverse = isInverse;
-
-            JoinCollection = isInverse
-                ? DB.GetRefCollection<TParent>($"[({propertyParent}){DB.CollectionName<TChild>()}~{DB.CollectionName<TParent>()}({propertyChild})]")
-                : DB.GetRefCollection<TParent>($"[({propertyChild}){DB.CollectionName<TParent>()}~{DB.CollectionName<TChild>()}({propertyParent})]");
-
-            CreateIndexesAsync(JoinCollection);
-        }
-
-        /// <summary>
-        /// Use this method to initialize the Many&lt;TChild&gt; properties with VB.Net
-        /// </summary>
-        /// <typeparam name="TParent">The type of the parent</typeparam>
-        /// <param name="parent">The parent entity instance</param>
-        /// <param name="propertyParent">Function(x) x.ParentProp</param>
-        /// <param name="propertyChild">Function(x) x.ChildProp</param>
-        /// <param name="isInverse">Specify if this is the inverse side of the relationship or not</param>
-        public void VB_InitManyToMany<TParent>(
-            TParent parent,
-            Expression<Func<TParent, object>> propertyParent,
-            Expression<Func<TChild, object>> propertyChild,
-            bool isInverse) where TParent : IEntity
+    /// <param name="session">An optional session if using within a transaction</param>
+    /// <param name="options">An optional AggregateOptions object</param>
+    /// <param name="cancellation">An optional cancellation token</param>
+    public Task<long> ChildrenCountAsync(DBContext context, CountOptions? options = null, CancellationToken cancellation = default)
+    {
+        parent.ThrowIfUnsaved();
+
+        //if (isInverse)
+        //{
+        //    return session == null
+        //           ? JoinCollection.CountDocumentsAsync(j => j.ChildID == parent.ID, options, cancellation)
+        //           : JoinCollection.CountDocumentsAsync(session, j => j.ChildID == parent.ID, options, cancellation);
+        //}
+        //else
+        //{
+        //    return session == null
+        //           ? JoinCollection.CountDocumentsAsync(j => j.ParentID == parent.ID, options, cancellation)
+        //           : JoinCollection.CountDocumentsAsync(session, j => j.ParentID == parent.ID, options, cancellation);
+        //}
+    }
+
+    /// <summary>
+    /// Creates an instance of Many&lt;TChild&gt; 
+    /// This is only needed in VB.Net
+    /// </summary>
+    public Many() { }
+
+    #region one-to-many-initializers
+    internal Many(object parent, string property)
+    {
+        Init((dynamic)parent, property);
+    }
+
+    private void Init<TParent>(TParent parent, string property) where TParent : IEntity
+    {
+        if (DB.DatabaseName<TParent>(null) != DB.DatabaseName<TChild>(null))
+            throw new NotSupportedException("Cross database relationships are not supported!");
+
+        this.parent = parent;
+        isInverse = false;
+        JoinCollection = DB.GetRefCollection<TParent>($"[{DB.CollectionName<TParent>()}~{DB.CollectionName<TChild>()}({property})]");
+        CreateIndexesAsync(JoinCollection);
+    }
+
+    /// <summary>
+    /// Use this method to initialize the Many&lt;TChild&gt; properties with VB.Net
+    /// </summary>
+    /// <typeparam name="TParent">The type of the parent</typeparam>
+    /// <param name="parent">The parent entity instance</param>
+    /// <param name="property">Function(x) x.PropName</param>
+    public void VB_InitOneToMany<TParent>(TParent parent, Expression<Func<TParent, object>> property) where TParent : IEntity
+    {
+        Init(parent, Prop.Property(property));
+    }
+    #endregion
+
+    #region many-to-many initializers
+    internal Many(object parent, string propertyParent, string propertyChild, bool isInverse)
+    {
+        Init((dynamic)parent, propertyParent, propertyChild, isInverse);
+    }
+
+    private void Init<TParent>(TParent parent, string propertyParent, string propertyChild, bool isInverse) where TParent : IEntity
+    {
+        this.parent = parent;
+        this.isInverse = isInverse;
+
+        JoinCollection = isInverse
+            ? DB.GetRefCollection<TParent>($"[({propertyParent}){DB.CollectionName<TChild>()}~{DB.CollectionName<TParent>()}({propertyChild})]")
+            : DB.GetRefCollection<TParent>($"[({propertyChild}){DB.CollectionName<TParent>()}~{DB.CollectionName<TChild>()}({propertyParent})]");
+
+        CreateIndexesAsync(JoinCollection);
+    }
+
+    /// <summary>
+    /// Use this method to initialize the Many&lt;TChild&gt; properties with VB.Net
+    /// </summary>
+    /// <typeparam name="TParent">The type of the parent</typeparam>
+    /// <param name="parent">The parent entity instance</param>
+    /// <param name="propertyParent">Function(x) x.ParentProp</param>
+    /// <param name="propertyChild">Function(x) x.ChildProp</param>
+    /// <param name="isInverse">Specify if this is the inverse side of the relationship or not</param>
+    public void VB_InitManyToMany<TParent>(
+        TParent parent,
+        Expression<Func<TParent, object>> propertyParent,
+        Expression<Func<TChild, object>> propertyChild,
+        bool isInverse) where TParent : IEntity
+    {
+        Init(parent, Prop.Property(propertyParent), Prop.Property(propertyChild), isInverse);
+    }
+    #endregion
+
+    private static Task CreateIndexesAsync(IMongoCollection<JoinRecord> collection)
+    {
+        //only create indexes once (best effort) per unique ref collection
+        if (!indexedCollections.Contains(collection.CollectionNamespace.CollectionName))
         {
-            Init(parent, Prop.Property(propertyParent), Prop.Property(propertyChild), isInverse);
-        }
-        #endregion
-
-        private static Task CreateIndexesAsync(IMongoCollection<JoinRecord> collection)
-        {
-            //only create indexes once (best effort) per unique ref collection
-            if (!indexedCollections.Contains(collection.CollectionNamespace.CollectionName))
-            {
-                indexedCollections.Add(collection.CollectionNamespace.CollectionName);
-                collection.Indexes.CreateManyAsync(
-                    new[] {
+            indexedCollections.Add(collection.CollectionNamespace.CollectionName);
+            collection.Indexes.CreateManyAsync(
+                new[] {
                         new CreateIndexModel<JoinRecord>(
                             Builders<JoinRecord>.IndexKeys.Ascending(r => r.ParentID),
                             new CreateIndexOptions
@@ -157,10 +158,9 @@ private static Task CreateIndexesAsync(IMongoCollection<JoinRecord> collection)
                             {
                                 Background = true,
                                 Name = "[ChildID]"
-                            })
-                    });
-            }
-            return Task.CompletedTask;
-        }
-    }
+                            })
+                });
+        }
+        return Task.CompletedTask;
+    }
 }
diff --git a/MongoDB.Entities/Relationships/NewMany.cs b/MongoDB.Entities/Relationships/NewMany.cs
new file mode 100644
index 000000000..da45852b4
--- /dev/null
+++ b/MongoDB.Entities/Relationships/NewMany.cs
@@ -0,0 +1,179 @@
+using MongoDB.Driver;
+using MongoDB.Driver.Linq;
+using System;
+using System.Collections.Generic;
+using System.Linq.Expressions;
+using System.Reflection;
+using System.Text;
+
+namespace MongoDB.Entities.NewMany;
+
+
+/*    
+ results in the following:
+ =========
+ Collection A:
+ _id
+ BRef: { ID: xxxxxxxx }
+ ------
+ Collection B:
+ _id
+ -------
+ Collection C:
+ _id
+ ------
+ Collection B~C(CRef):
+ ParentId: b._id
+ ChildId: c._id
+*/
+/*
+Queries needed:
+One-Many (B-A)
+ * for a document B (parent) get children (A) {collection A where BRef == B.id}
+ * for a document A (child) get parent (B) {A.BRef}
+ * for multiple documents B (parents) get children (A) [to solve N+1 problem] {collection A where BRef.ID in b_ids}
+ * for multiple documents A (children) get parents (B) [to solve N+1 problem] {collection B where _id in a_BRefs}
+ * Add A to the Many list in B
+ * set A.BRef = B.Id
+
+Many(Parent)-Many(Child) (B-C)
+ * for a document B (parent) get children (C) {collection B~C(CRef) where ParentId==B.id} then {join result ChildId with collection C}
+ * for a document C (child) get parents (B) {collection B~C(CRef) where ChildId==C.id} then {join result ParentId with collection B}
+ * for multiple documents B (parents) get children (C) [to solve N+1 problem] {collection B~C(CRef) where ParentId in b_ids} then {join result ChildId with collection C}
+ * for multiple documents C (children) get parents (B) [to solve N+1 problem] {collection B~C(CRef) where ChildId in c_ids} then {join result ParentId with collection B}
+ * Add B to the Many list in C
+ * Add C to the Many list in B
+ * Add an arbitrary join record
+ */
+class A : Entity
+{
+    public One<B>? SingleB1 { get; set; }
+    public One<B>? SingleB2 { get; set; }
+}
+class B : Entity
+{
+    public Many<A> ManyAVia1 { get; set; }
+    public Many<A> ManyAVia2 { get; set; }
+
+    [OwnerSide]
+    public Many<C> ManyC { get; set; }
+
+    public B()
+    {
+        ManyAVia1 = this.InitManyToOne(x => x.ManyAVia1, x => x.SingleB1);
+        ManyAVia2 = this.InitManyToOne(x => x.ManyAVia2, x => x.SingleB2);
+
+        ManyC = this.InitManyToMany(x => x.ManyC, x => x.ManyB);
+    }
+}
+class C : Entity
+{
+    [InverseSide]
+    public Many<B> ManyB { get; set; }
+
+    public C()
+    {
+        ManyB = this.InitManyToMany(x => x.ManyB, x => x.ManyC);
+    }
+}
+
+/// <summary>
+/// Marker class
+/// </summary>
+/// <typeparam name="TChild"></typeparam>
+public abstract class Many<TChild> where TChild : IEntity
+{
+    protected Many(PropertyInfo parentProperty, PropertyInfo childProperty)
+    {
+        ParentProperty = parentProperty;
+        ChildProperty = childProperty;
+    }
+
+    public PropertyInfo ParentProperty { get; }
+    public PropertyInfo ChildProperty { get; }
+
+
+    public abstract IMongoQueryable<TChild> GetChildrenQuery(DBContext context, string? childCollectionName = null, IMongoCollection<TChild>? collection = null);
+    public abstract Find<TChild> GetChildFind(DBContext context, string? childCollectionName = null, IMongoCollection<TChild>? collection = null);
+    public abstract Find<TChild, TProjection> GetChildFind<TProjection>(DBContext context, string? childCollectionName = null, IMongoCollection<TChild>? collection = null);
+}
+internal abstract class Many<TParent, TChild> : Many<TChild> where TParent : IEntity where TChild : IEntity
+{
+    protected Many(PropertyInfo parentProperty, PropertyInfo childProperty) : base(parentProperty, childProperty)
+    {
+    }
+}
+internal class ManyToMany<TParent, TChild> : Many<TParent, TChild> where TParent : IEntity where TChild : IEntity
+{
+    public ManyToMany(bool isParentOwner, PropertyInfo parentProperty, PropertyInfo childProperty) : base(parentProperty, childProperty)
+    {
+        IsParentOwner = isParentOwner;
+    }
+
+    public bool IsParentOwner { get; }
+}
+
+internal class ManyToOne<TParent, TChild> : Many<TParent, TChild> where TParent : IEntity where TChild : IEntity
+{
+    public ManyToOne(PropertyInfo parentProperty, PropertyInfo childProperty) : base(parentProperty, childProperty)
+    {
+    }
+}
+
+
+public static class RelationsExt
+{
+    public static PropertyInfo GetPropertyInfo<TSource, TProperty>(this Expression<Func<TSource, TProperty>> propertyLambda)
+    {
+        Type type = typeof(TSource);
+
+        if (propertyLambda.Body is not MemberExpression member)
+            throw new ArgumentException(string.Format(
+                "Expression '{0}' refers to a method, not a property.",
+                propertyLambda.ToString()));
+
+
+        if (member.Member is not PropertyInfo propInfo)
+            throw new ArgumentException(string.Format(
+                "Expression '{0}' refers to a field, not a property.",
+                propertyLambda.ToString()));
+
+        if (type != propInfo.ReflectedType &&
+            !type.IsSubclassOf(propInfo.ReflectedType))
+            throw new ArgumentException(string.Format(
+                "Expression '{0}' refers to a property that is not from type {1}.",
+                propertyLambda.ToString(),
+                type));
+
+        return propInfo;
+    }
+
+    public static Many<TChild> InitManyToMany<TParent, TChild>(this TParent _, Expression<Func<TParent, Many<TChild>>> propertyExpression, Expression<Func<TChild, Many<TParent>>> propertyOtherSide) where TParent : IEntity where TChild : IEntity
+    {
+        var property = propertyExpression.GetPropertyInfo();
+        var hasOwnerAttrib = property.IsDefined(typeof(OwnerSideAttribute), false);
+        var hasInverseAttrib = property.IsDefined(typeof(InverseSideAttribute), false);
+        if (hasOwnerAttrib && hasInverseAttrib) throw new InvalidOperationException("Only one type of relationship side attribute is allowed on a property");
+        if (!hasOwnerAttrib && !hasInverseAttrib) throw new InvalidOperationException("Missing attribute for determining relationship side of a many-to-many relationship");
+
+        var osProperty = propertyOtherSide.GetPropertyInfo();
+        var osHasOwnerAttrib = osProperty.IsDefined(typeof(OwnerSideAttribute), false);
+        var osHasInverseAttrib = osProperty.IsDefined(typeof(InverseSideAttribute), false);
+        if (osHasOwnerAttrib && osHasInverseAttrib) throw new InvalidOperationException("Only one type of relationship side attribute is allowed on a property");
+        if (!osHasOwnerAttrib && !osHasInverseAttrib) throw new InvalidOperationException("Missing attribute for determining relationship side of a many-to-many relationship");
+
+        if ((hasOwnerAttrib == osHasOwnerAttrib) || (hasInverseAttrib == osHasInverseAttrib)) throw new InvalidOperationException("Both sides of the relationship cannot have the same attribute");
+        var res = new ManyToMany<TParent, TChild>(hasInverseAttrib, property, osProperty);
+        //should we set the property ourself or let the user handle it ?
+        //property.SetValue(parent, res);
+        return res;
+    }
+    public static Many<TChild> InitManyToOne<TParent, TChild>(this TParent _, Expression<Func<TParent, Many<TChild>>> propertyExpression, Expression<Func<TChild, One<TParent>?>> propertyOtherSide) where TParent : IEntity where TChild : IEntity
+    {
+        var property = propertyExpression.GetPropertyInfo();
+        var osProperty = propertyOtherSide.GetPropertyInfo();
+
+        return new ManyToOne<TParent, TChild>(property, osProperty);
+
+    }
+}
\ No newline at end of file

From bc27bc47fc2db5ad44abe03f7fc20a7f0c79f05b Mon Sep 17 00:00:00 2001
From: Ahmed Fwela <ahmednfwela@bdaya-dev.com>
Date: Wed, 10 Nov 2021 23:28:07 +0200
Subject: [PATCH 20/26] WIP relations

---
 MongoDB.Entities/Relationships/NewMany.cs | 57 +++++++++++++++++------
 1 file changed, 42 insertions(+), 15 deletions(-)

diff --git a/MongoDB.Entities/Relationships/NewMany.cs b/MongoDB.Entities/Relationships/NewMany.cs
index da45852b4..e2a98d641 100644
--- a/MongoDB.Entities/Relationships/NewMany.cs
+++ b/MongoDB.Entities/Relationships/NewMany.cs
@@ -89,35 +89,62 @@ protected Many(PropertyInfo parentProperty, PropertyInfo childProperty)
         ChildProperty = childProperty;
     }
 
-    public PropertyInfo ParentProperty { get; }
-    public PropertyInfo ChildProperty { get; }
-
+    internal PropertyInfo ParentProperty { get; }
+    internal PropertyInfo ChildProperty { get; }
 
     public abstract IMongoQueryable<TChild> GetChildrenQuery(DBContext context, string? childCollectionName = null, IMongoCollection<TChild>? collection = null);
-    public abstract Find<TChild> GetChildFind(DBContext context, string? childCollectionName = null, IMongoCollection<TChild>? collection = null);
-    public abstract Find<TChild, TProjection> GetChildFind<TProjection>(DBContext context, string? childCollectionName = null, IMongoCollection<TChild>? collection = null);
+    public Find<TChild, TChild> GetChildrenFind(DBContext context, string? childCollectionName = null, IMongoCollection<TChild>? collection = null) => GetChildrenFind<TChild>(context, childCollectionName, collection);
+    public abstract Find<TChild, TProjection> GetChildrenFind<TProjection>(DBContext context, string? childCollectionName = null, IMongoCollection<TChild>? collection = null);
 }
-internal abstract class Many<TParent, TChild> : Many<TChild> where TParent : IEntity where TChild : IEntity
+public abstract class Many<TParent, TChild> : Many<TChild> where TParent : IEntity where TChild : IEntity
 {
-    protected Many(PropertyInfo parentProperty, PropertyInfo childProperty) : base(parentProperty, childProperty)
+    public TParent Parent { get; }
+    protected Many(TParent parent, PropertyInfo parentProperty, PropertyInfo childProperty) : base(parentProperty, childProperty)
     {
+        Parent = parent;
     }
+    public FilterDefinition<TChild> GetFilterForSingleDocument() => Builders<TChild>.Filter.Eq(ChildProperty.Name, Parent.ID);
+
+
 }
-internal class ManyToMany<TParent, TChild> : Many<TParent, TChild> where TParent : IEntity where TChild : IEntity
+public sealed class ManyToMany<TParent, TChild> : Many<TParent, TChild> where TParent : IEntity where TChild : IEntity
 {
-    public ManyToMany(bool isParentOwner, PropertyInfo parentProperty, PropertyInfo childProperty) : base(parentProperty, childProperty)
+    public ManyToMany(bool isParentOwner, TParent parent, PropertyInfo parentProperty, PropertyInfo childProperty) : base(parent, parentProperty, childProperty)
     {
         IsParentOwner = isParentOwner;
     }
 
     public bool IsParentOwner { get; }
+
+    public override Find<TChild, TProjection> GetChildrenFind<TProjection>(DBContext context, string? childCollectionName = null, IMongoCollection<TChild>? collection = null)
+    {
+        throw new NotImplementedException();
+    }
+
+    public override IMongoQueryable<TChild> GetChildrenQuery(DBContext context, string? childCollectionName = null, IMongoCollection<TChild>? collection = null)
+    {
+        throw new NotImplementedException();
+    }
 }
 
-internal class ManyToOne<TParent, TChild> : Many<TParent, TChild> where TParent : IEntity where TChild : IEntity
+public sealed class ManyToOne<TParent, TChild> : Many<TParent, TChild> where TParent : IEntity where TChild : IEntity
 {
-    public ManyToOne(PropertyInfo parentProperty, PropertyInfo childProperty) : base(parentProperty, childProperty)
+    public ManyToOne(TParent parent, PropertyInfo parentProperty, PropertyInfo childProperty) : base(parent, parentProperty, childProperty)
+    {
+    }
+
+    public override Find<TChild, TProjection> GetChildrenFind<TProjection>(DBContext context, string? childCollectionName = null, IMongoCollection<TChild>? childCollection = null)
     {
+        return context.Find<TChild, TProjection>(childCollectionName, childCollection)
+            .Match(GetFilterForSingleDocument()); //BRef==Parent.Id
     }
+
+    public override IMongoQueryable<TChild> GetChildrenQuery(DBContext context, string? childCollectionName = null, IMongoCollection<TChild>? childCollection = null)
+    {
+        return context.Queryable(collectionName: childCollectionName, collection: childCollection)
+             .Where(_ => GetFilterForSingleDocument().Inject());
+    }
+
 }
 
 
@@ -148,7 +175,7 @@ public static PropertyInfo GetPropertyInfo<TSource, TProperty>(this Expression<F
         return propInfo;
     }
 
-    public static Many<TChild> InitManyToMany<TParent, TChild>(this TParent _, Expression<Func<TParent, Many<TChild>>> propertyExpression, Expression<Func<TChild, Many<TParent>>> propertyOtherSide) where TParent : IEntity where TChild : IEntity
+    public static ManyToMany<TParent, TChild> InitManyToMany<TParent, TChild>(this TParent parent, Expression<Func<TParent, Many<TChild>>> propertyExpression, Expression<Func<TChild, Many<TParent>>> propertyOtherSide) where TParent : IEntity where TChild : IEntity
     {
         var property = propertyExpression.GetPropertyInfo();
         var hasOwnerAttrib = property.IsDefined(typeof(OwnerSideAttribute), false);
@@ -163,17 +190,17 @@ public static Many<TChild> InitManyToMany<TParent, TChild>(this TParent _, Expre
         if (!osHasOwnerAttrib && !osHasInverseAttrib) throw new InvalidOperationException("Missing attribute for determining relationship side of a many-to-many relationship");
 
         if ((hasOwnerAttrib == osHasOwnerAttrib) || (hasInverseAttrib == osHasInverseAttrib)) throw new InvalidOperationException("Both sides of the relationship cannot have the same attribute");
-        var res = new ManyToMany<TParent, TChild>(hasInverseAttrib, property, osProperty);
+        var res = new ManyToMany<TParent, TChild>(hasInverseAttrib, parent, property, osProperty);
         //should we set the property ourself or let the user handle it ?
         //property.SetValue(parent, res);
         return res;
     }
-    public static Many<TChild> InitManyToOne<TParent, TChild>(this TParent _, Expression<Func<TParent, Many<TChild>>> propertyExpression, Expression<Func<TChild, One<TParent>?>> propertyOtherSide) where TParent : IEntity where TChild : IEntity
+    public static ManyToOne<TParent, TChild> InitManyToOne<TParent, TChild>(this TParent parent, Expression<Func<TParent, Many<TChild>>> propertyExpression, Expression<Func<TChild, One<TParent>?>> propertyOtherSide) where TParent : IEntity where TChild : IEntity
     {
         var property = propertyExpression.GetPropertyInfo();
         var osProperty = propertyOtherSide.GetPropertyInfo();
 
-        return new ManyToOne<TParent, TChild>(property, osProperty);
+        return new ManyToOne<TParent, TChild>(parent, property, osProperty);
 
     }
 }
\ No newline at end of file

From 537303bfd2f13bf787df4b9fda39790fe6aee86e Mon Sep 17 00:00:00 2001
From: Ahmed Fwela <ahmednfwela@bdaya-dev.com>
Date: Thu, 11 Nov 2021 10:29:00 +0200
Subject: [PATCH 21/26] generic Id WIP

---
 MongoDB.Entities/Builders/Distinct.cs         |  188 ++-
 MongoDB.Entities/Builders/FilterQueryBase.cs  |  290 ++--
 MongoDB.Entities/Builders/Find.cs             |  530 ++++----
 .../Builders/ICollectionRelated.cs            |   26 +-
 MongoDB.Entities/Builders/Index.cs            |  313 +++--
 MongoDB.Entities/Builders/PagedSearch.cs      |  424 +++---
 MongoDB.Entities/Builders/Replace.cs          |  219 ++-
 .../Builders/SortFilterQueryBase.cs           |   77 +-
 MongoDB.Entities/Builders/Update.cs           |  616 +++++----
 MongoDB.Entities/Builders/UpdateAndGet.cs     |   38 +-
 MongoDB.Entities/Core/Attributes.cs           |  215 ++-
 MongoDB.Entities/Core/DBContextOptions.cs     |   13 +-
 MongoDB.Entities/Core/Date.cs                 |  164 ++-
 MongoDB.Entities/Core/DoubleMetaphone.cs      | 1199 ++++++++---------
 MongoDB.Entities/Core/Entity.cs               |   48 +-
 MongoDB.Entities/Core/EntityCache.cs          |  184 +--
 MongoDB.Entities/Core/FileEntity.cs           |  461 +++----
 MongoDB.Entities/Core/FuzzyString.cs          |  151 +--
 MongoDB.Entities/Core/GeoNear.cs              |  108 +-
 MongoDB.Entities/Core/ICreatedOn.cs           |   19 +-
 MongoDB.Entities/Core/IEntity.cs              |   60 +-
 MongoDB.Entities/Core/IModifiedOn.cs          |   19 +-
 .../Core/IgnoreManyPropsConvention.cs         |   18 +-
 MongoDB.Entities/Core/LevenshteinDistance.cs  |   83 +-
 MongoDB.Entities/Core/Logic.cs                |   80 +-
 MongoDB.Entities/Core/ModifiedBy.cs           |   11 +-
 MongoDB.Entities/Core/Prop.cs                 |  242 ++--
 MongoDB.Entities/Core/SequenceCounter.cs      |   22 +-
 MongoDB.Entities/Core/Template.cs             |   12 +-
 MongoDB.Entities/Core/Transaction.cs          |   76 +-
 MongoDB.Entities/Core/Watcher.cs              |  795 ++++++-----
 MongoDB.Entities/DB/DB.Collection.cs          |    4 +-
 .../DBContext/DBContext.Collection.cs         |    4 +-
 MongoDB.Entities/DBContext/DBContext.Count.cs |   12 +-
 .../DBContext/DBContext.Delete.cs             |   52 +-
 .../DBContext/DBContext.Distinct.cs           |    7 +-
 MongoDB.Entities/DBContext/DBContext.File.cs  |   10 +-
 MongoDB.Entities/DBContext/DBContext.Find.cs  |   14 +-
 .../DBContext/DBContext.Fluent.cs             |    4 +-
 .../DBContext/DBContext.GeoNear.cs            |    2 +-
 MongoDB.Entities/DBContext/DBContext.Index.cs |    7 +-
 .../DBContext/DBContext.Insert.cs             |   40 +-
 .../DBContext/DBContext.PagedSearch.cs        |   43 +-
 .../DBContext/DBContext.Pipeline.cs           |   12 +-
 .../DBContext/DBContext.Queryable.cs          |    2 +-
 .../DBContext/DBContext.Replace.cs            |    7 +-
 MongoDB.Entities/DBContext/DBContext.Save.cs  |   65 +-
 .../DBContext/DBContext.Sequence.cs           |    4 +-
 .../DBContext/DBContext.Transaction.cs        |    8 +-
 .../DBContext/DBContext.Update.cs             |   79 +-
 .../DBContext/DBContext.Watcher.cs            |   50 +-
 MongoDB.Entities/DBContext/DBContext.cs       |   37 +-
 MongoDB.Entities/Extensions/Entity.cs         |    9 +-
 MongoDB.Entities/GlobalUsing.cs               |    8 +
 MongoDB.Entities/MongoDB.Entities.csproj      |    3 +
 MongoDB.Entities/Relationships/JoinRecord.cs  |   43 +-
 .../Relationships/Many.Queryable.cs           |  253 ++--
 MongoDB.Entities/Relationships/Many.cs        |    5 +-
 MongoDB.Entities/Relationships/NewMany.cs     |  155 ++-
 MongoDB.Entities/Relationships/One.cs         |   41 +-
 60 files changed, 3904 insertions(+), 3777 deletions(-)
 create mode 100644 MongoDB.Entities/GlobalUsing.cs

diff --git a/MongoDB.Entities/Builders/Distinct.cs b/MongoDB.Entities/Builders/Distinct.cs
index 9f4f63577..f2bffb03f 100644
--- a/MongoDB.Entities/Builders/Distinct.cs
+++ b/MongoDB.Entities/Builders/Distinct.cs
@@ -1,119 +1,117 @@
-using MongoDB.Driver;
-using System;
-using System.Collections.Generic;
-using System.Linq.Expressions;
-using System.Threading;
-using System.Threading.Tasks;
+namespace MongoDB.Entities;
 
-namespace MongoDB.Entities
+public class DistinctBase<T, TId, TProperty, TSelf> : FilterQueryBase<T, TId, TSelf>
+    where TId : IComparable<TId>, IEquatable<TId>
+    where T : IEntity<TId>
+    where TSelf : DistinctBase<T, TId, TProperty, TSelf>
 {
-    public class DistinctBase<T, TProperty, TSelf> : FilterQueryBase<T, TSelf> where T : IEntity where TSelf : DistinctBase<T, TProperty, TSelf>
-    {
-        internal DistinctOptions _options = new();
-        internal FieldDefinition<T, TProperty>? _field;
-
-        internal DistinctBase(DistinctBase<T, TProperty, TSelf> other) : base(other)
-        {
-            _options = other._options;
-            _field = other._field;
-        }
-        internal DistinctBase(Dictionary<Type, (object filterDef, bool prepend)> globalFilters) : base(globalFilters)
-        {
-            _globalFilters = globalFilters;
-        }
+    internal DistinctOptions _options = new();
+    internal FieldDefinition<T, TProperty>? _field;
 
+    internal DistinctBase(DistinctBase<T, TId, TProperty, TSelf> other) : base(other)
+    {
+        _options = other._options;
+        _field = other._field;
+    }
+    internal DistinctBase(Dictionary<Type, (object filterDef, bool prepend)> globalFilters) : base(globalFilters)
+    {
+        _globalFilters = globalFilters;
+    }
 
-        private TSelf This => (TSelf)this;
 
+    private TSelf This => (TSelf)this;
 
-        /// <summary>
-        /// Specify an option for this find command (use multiple times if needed)
-        /// </summary>
-        /// <param name="option">x => x.OptionName = OptionValue</param>
-        public TSelf Option(Action<DistinctOptions> option)
-        {
-            option(_options);
-            return This;
-        }
 
-        /// <summary>
-        /// Specify the property you want to get the unique values for (as a string path)
-        /// </summary>
-        /// <param name="property">ex: "Address.Street"</param>
-        public TSelf Property(string property)
-        {
-            _field = property;
-            return This;
-        }
+    /// <summary>
+    /// Specify an option for this find command (use multiple times if needed)
+    /// </summary>
+    /// <param name="option">x => x.OptionName = OptionValue</param>
+    public TSelf Option(Action<DistinctOptions> option)
+    {
+        option(_options);
+        return This;
+    }
 
-        /// <summary>
-        /// Specify the property you want to get the unique values for (as a member expression)
-        /// </summary>
-        /// <param name="property">x => x.Address.Street</param>
-        public TSelf Property(Expression<Func<T, object>> property)
-        {
-            _field = property.FullPath();
-            return This;
-        }
+    /// <summary>
+    /// Specify the property you want to get the unique values for (as a string path)
+    /// </summary>
+    /// <param name="property">ex: "Address.Street"</param>
+    public TSelf Property(string property)
+    {
+        _field = property;
+        return This;
     }
 
     /// <summary>
-    /// Represents a MongoDB Distinct command where you can get back distinct values for a given property of a given Entity.
+    /// Specify the property you want to get the unique values for (as a member expression)
     /// </summary>
-    /// <typeparam name="T">Any Entity that implements IEntity interface</typeparam>
-    /// <typeparam name="TProperty">The type of the property of the entity you'd like to get unique values for</typeparam>
-    public class Distinct<T, TProperty> : DistinctBase<T, TProperty, Distinct<T, TProperty>>, ICollectionRelated<T> where T : IEntity
+    /// <param name="property">x => x.Address.Street</param>
+    public TSelf Property(Expression<Func<T, object>> property)
     {
-        public DBContext Context { get; }
-        public IMongoCollection<T> Collection { get; }
+        _field = property.FullPath();
+        return This;
+    }
+}
 
-        internal Distinct(
-            DBContext context,
-            IMongoCollection<T> collection,
-            DistinctBase<T, TProperty, Distinct<T, TProperty>> other) : base(other)
-        {
-            Context = context;
-            Collection = collection;
-        }
-        internal Distinct(
-            DBContext context,
-            IMongoCollection<T> collection) : base(globalFilters: context.GlobalFilters)
-        {
-            Context = context;
-            Collection = collection;
-        }
+/// <summary>
+/// Represents a MongoDB Distinct command where you can get back distinct values for a given property of a given Entity.
+/// </summary>
+/// <typeparam name="T">Any Entity that implements IEntity interface</typeparam>
+/// <typeparam name="TProperty">The type of the property of the entity you'd like to get unique values for</typeparam>
+/// <typeparam name="TId">The type of the id</typeparam>
+public class Distinct<T, TId, TProperty> : DistinctBase<T, TId, TProperty, Distinct<T, TId, TProperty>>, ICollectionRelated<T>
+     where TId : IComparable<TId>, IEquatable<TId>
+    where T : IEntity<TId>
+{
+    public DBContext Context { get; }
+    public IMongoCollection<T> Collection { get; }
 
-        /// <summary>
-        /// Run the Distinct command in MongoDB server and get a cursor instead of materialized results
-        /// </summary>
-        /// <param name="cancellation">An optional cancellation token</param>
-        public Task<IAsyncCursor<TProperty>> ExecuteCursorAsync(CancellationToken cancellation = default)
-        {
-            if (_field == null)
-                throw new InvalidOperationException("Please use the .Property() method to specify the field to use for obtaining unique values for!");
+    internal Distinct(
+        DBContext context,
+        IMongoCollection<T> collection,
+        DistinctBase<T, TId, TProperty, Distinct<T, TId, TProperty>> other) : base(other)
+    {
+        Context = context;
+        Collection = collection;
+    }
+    internal Distinct(
+        DBContext context,
+        IMongoCollection<T> collection) : base(globalFilters: context.GlobalFilters)
+    {
+        Context = context;
+        Collection = collection;
+    }
 
-            var mergedFilter = Logic.MergeWithGlobalFilter(_ignoreGlobalFilters, _globalFilters, _filter);
+    /// <summary>
+    /// Run the Distinct command in MongoDB server and get a cursor instead of materialized results
+    /// </summary>
+    /// <param name="cancellation">An optional cancellation token</param>
+    public Task<IAsyncCursor<TProperty>> ExecuteCursorAsync(CancellationToken cancellation = default)
+    {
+        if (_field == null)
+            throw new InvalidOperationException("Please use the .Property() method to specify the field to use for obtaining unique values for!");
 
-            return Context.Session is IClientSessionHandle session
-                   ? Collection.DistinctAsync(session, _field, mergedFilter, _options, cancellation)
-                   : Collection.DistinctAsync(_field, mergedFilter, _options, cancellation);
-        }
+        var mergedFilter = Logic.MergeWithGlobalFilter(_ignoreGlobalFilters, _globalFilters, _filter);
 
-        /// <summary>
-        /// Run the Distinct command in MongoDB server and get a list of unique property values
-        /// </summary>
-        /// <param name="cancellation">An optional cancellation token</param>
-        public async Task<List<TProperty>> ExecuteAsync(CancellationToken cancellation = default)
+        return Context.Session is IClientSessionHandle session
+               ? Collection.DistinctAsync(session, _field, mergedFilter, _options, cancellation)
+               : Collection.DistinctAsync(_field, mergedFilter, _options, cancellation);
+    }
+
+    /// <summary>
+    /// Run the Distinct command in MongoDB server and get a list of unique property values
+    /// </summary>
+    /// <param name="cancellation">An optional cancellation token</param>
+    public async Task<List<TProperty>> ExecuteAsync(CancellationToken cancellation = default)
+    {
+        var list = new List<TProperty>();
+        using (var csr = await ExecuteCursorAsync(cancellation).ConfigureAwait(false))
         {
-            var list = new List<TProperty>();
-            using (var csr = await ExecuteCursorAsync(cancellation).ConfigureAwait(false))
+            while (await csr.MoveNextAsync(cancellation).ConfigureAwait(false))
             {
-                while (await csr.MoveNextAsync(cancellation).ConfigureAwait(false))
-                {
-                    list.AddRange(csr.Current);
-                }
+                list.AddRange(csr.Current);
             }
-            return list;
         }
+        return list;
     }
 }
diff --git a/MongoDB.Entities/Builders/FilterQueryBase.cs b/MongoDB.Entities/Builders/FilterQueryBase.cs
index ece5a1c99..eaa32de9a 100644
--- a/MongoDB.Entities/Builders/FilterQueryBase.cs
+++ b/MongoDB.Entities/Builders/FilterQueryBase.cs
@@ -1,169 +1,167 @@
-using MongoDB.Driver;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Linq.Expressions;
-namespace MongoDB.Entities
+namespace MongoDB.Entities;
+
+public abstract class FilterQueryBase<T, TId, TSelf>
+    where TId : IComparable<TId>, IEquatable<TId>
+    where T : IEntity<TId>
+    where TSelf : FilterQueryBase<T, TId, TSelf>
+
 {
-    public abstract class FilterQueryBase<T, TSelf> where T : IEntity where TSelf : FilterQueryBase<T, TSelf>
+    internal FilterDefinition<T> _filter = Builders<T>.Filter.Empty;
+    internal Dictionary<Type, (object filterDef, bool prepend)> _globalFilters;
+    internal bool _ignoreGlobalFilters;
+
+    internal FilterQueryBase(FilterQueryBase<T, TId, TSelf> other) : this(globalFilters: other._globalFilters)
     {
-        internal FilterDefinition<T> _filter = Builders<T>.Filter.Empty;
-        internal Dictionary<Type, (object filterDef, bool prepend)> _globalFilters;
-        internal bool _ignoreGlobalFilters;
+        _filter = other._filter;
+        _ignoreGlobalFilters = other._ignoreGlobalFilters;
+    }
+    internal FilterQueryBase(Dictionary<Type, (object filterDef, bool prepend)> globalFilters)
+    {
+        _globalFilters = globalFilters;
+    }
 
-        internal FilterQueryBase(FilterQueryBase<T, TSelf> other) : this(globalFilters: other._globalFilters)
-        {
-            _filter = other._filter;
-            _ignoreGlobalFilters = other._ignoreGlobalFilters;
-        }
-        internal FilterQueryBase(Dictionary<Type, (object filterDef, bool prepend)> globalFilters)
-        {
-            _globalFilters = globalFilters;
-        }
+    protected FilterDefinition<T> MergedFilter => Logic.MergeWithGlobalFilter(_ignoreGlobalFilters, _globalFilters, _filter);
+    private TSelf This => (TSelf)this;
 
-        protected FilterDefinition<T> MergedFilter => Logic.MergeWithGlobalFilter(_ignoreGlobalFilters, _globalFilters, _filter);
-        private TSelf This => (TSelf)this;
 
+    /// <summary>
+    /// Specify that this operation should ignore any global filters
+    /// </summary>
+    public TSelf IgnoreGlobalFilters()
+    {
+        _ignoreGlobalFilters = true;
+        return This;
+    }
 
-        /// <summary>
-        /// Specify that this operation should ignore any global filters
-        /// </summary>
-        public TSelf IgnoreGlobalFilters()
-        {
-            _ignoreGlobalFilters = true;
-            return This;
-        }
 
 
+    /// <summary>
+    /// Specify an IEntity ID as the matching criteria
+    /// </summary>
+    /// <param name="ID">A unique IEntity ID</param>
+    public TSelf Match(TId ID)
+    {
+        return Match(f => f.Eq(t => t.ID, ID));
+    }
 
-        /// <summary>
-        /// Specify an IEntity ID as the matching criteria
-        /// </summary>
-        /// <param name="ID">A unique IEntity ID</param>
-        public TSelf Match(string ID)
-        {
-            return Match(f => f.Eq(t => t.ID, ID));
-        }
+    /// <summary>
+    /// Specify the matching criteria with a lambda expression
+    /// </summary>
+    /// <param name="expression">x => x.Property == Value</param>
+    public TSelf Match(Expression<Func<T, bool>> expression)
+    {
+        return Match(f => f.Where(expression));
+    }
 
-        /// <summary>
-        /// Specify the matching criteria with a lambda expression
-        /// </summary>
-        /// <param name="expression">x => x.Property == Value</param>
-        public TSelf Match(Expression<Func<T, bool>> expression)
-        {
-            return Match(f => f.Where(expression));
-        }
+    /// <summary>
+    /// Specify the matching criteria with a filter expression
+    /// </summary>
+    /// <param name="filter">f => f.Eq(x => x.Prop, Value) &amp; f.Gt(x => x.Prop, Value)</param>
+    public TSelf Match(Func<FilterDefinitionBuilder<T>, FilterDefinition<T>> filter)
+    {
+        _filter &= filter(Builders<T>.Filter);
+        return This;
+    }
 
-        /// <summary>
-        /// Specify the matching criteria with a filter expression
-        /// </summary>
-        /// <param name="filter">f => f.Eq(x => x.Prop, Value) &amp; f.Gt(x => x.Prop, Value)</param>
-        public TSelf Match(Func<FilterDefinitionBuilder<T>, FilterDefinition<T>> filter)
-        {
-            _filter &= filter(Builders<T>.Filter);
-            return This;
-        }
+    /// <summary>
+    /// Specify the matching criteria with a filter definition
+    /// </summary>
+    /// <param name="filterDefinition">A filter definition</param>
+    public TSelf Match(FilterDefinition<T> filterDefinition)
+    {
+        _filter &= filterDefinition;
+        return This;
+    }
 
-        /// <summary>
-        /// Specify the matching criteria with a filter definition
-        /// </summary>
-        /// <param name="filterDefinition">A filter definition</param>
-        public TSelf Match(FilterDefinition<T> filterDefinition)
-        {
-            _filter &= filterDefinition;
-            return This;
-        }
+    /// <summary>
+    /// Specify the matching criteria with a template
+    /// </summary>
+    /// <param name="template">A Template with a find query</param>
+    public TSelf Match(Template template)
+    {
+        _filter &= template.RenderToString();
+        return This;
+    }
 
-        /// <summary>
-        /// Specify the matching criteria with a template
-        /// </summary>
-        /// <param name="template">A Template with a find query</param>
-        public TSelf Match(Template template)
+    /// <summary>
+    /// Specify a search term to find results from the text index of this particular collection.
+    /// <para>TIP: Make sure to define a text index with DB.Index&lt;T&gt;() before searching</para>
+    /// </summary>
+    /// <param name="searchType">The type of text matching to do</param>
+    /// <param name="searchTerm">The search term</param>
+    /// <param name="caseSensitive">Case sensitivity of the search (optional)</param>
+    /// <param name="diacriticSensitive">Diacritic sensitivity of the search (optional)</param>
+    /// <param name="language">The language for the search (optional)</param>
+    public TSelf Match(Search searchType, string searchTerm, bool caseSensitive = false, bool diacriticSensitive = false, string? language = null)
+    {
+        if (searchType == Search.Fuzzy)
         {
-            _filter &= template.RenderToString();
-            return This;
+            searchTerm = searchTerm.ToDoubleMetaphoneHash();
+            caseSensitive = false;
+            diacriticSensitive = false;
+            language = null;
         }
 
-        /// <summary>
-        /// Specify a search term to find results from the text index of this particular collection.
-        /// <para>TIP: Make sure to define a text index with DB.Index&lt;T&gt;() before searching</para>
-        /// </summary>
-        /// <param name="searchType">The type of text matching to do</param>
-        /// <param name="searchTerm">The search term</param>
-        /// <param name="caseSensitive">Case sensitivity of the search (optional)</param>
-        /// <param name="diacriticSensitive">Diacritic sensitivity of the search (optional)</param>
-        /// <param name="language">The language for the search (optional)</param>
-        public TSelf Match(Search searchType, string searchTerm, bool caseSensitive = false, bool diacriticSensitive = false, string? language = null)
-        {
-            if (searchType == Search.Fuzzy)
-            {
-                searchTerm = searchTerm.ToDoubleMetaphoneHash();
-                caseSensitive = false;
-                diacriticSensitive = false;
-                language = null;
-            }
-
-            return Match(
-                f => f.Text(
-                    searchTerm,
-                    new TextSearchOptions
-                    {
-                        CaseSensitive = caseSensitive,
-                        DiacriticSensitive = diacriticSensitive,
-                        Language = language
-                    }));
-        }
+        return Match(
+            f => f.Text(
+                searchTerm,
+                new TextSearchOptions
+                {
+                    CaseSensitive = caseSensitive,
+                    DiacriticSensitive = diacriticSensitive,
+                    Language = language
+                }));
+    }
 
-        /// <summary>
-        /// Specify criteria for matching entities based on GeoSpatial data (longitude &amp; latitude)
-        /// <para>TIP: Make sure to define a Geo2DSphere index with DB.Index&lt;T&gt;() before searching</para>
-        /// <para>Note: DB.FluentGeoNear() supports more advanced options</para>
-        /// </summary>
-        /// <param name="coordinatesProperty">The property where 2DCoordinates are stored</param>
-        /// <param name="nearCoordinates">The search point</param>
-        /// <param name="maxDistance">Maximum distance in meters from the search point</param>
-        /// <param name="minDistance">Minimum distance in meters from the search point</param>
-        public TSelf Match(Expression<Func<T, object>> coordinatesProperty, Coordinates2D nearCoordinates, double? maxDistance = null, double? minDistance = null)
-        {
-            return Match(f => f.Near(coordinatesProperty, nearCoordinates.ToGeoJsonPoint(), maxDistance, minDistance));
-        }
+    /// <summary>
+    /// Specify criteria for matching entities based on GeoSpatial data (longitude &amp; latitude)
+    /// <para>TIP: Make sure to define a Geo2DSphere index with DB.Index&lt;T&gt;() before searching</para>
+    /// <para>Note: DB.FluentGeoNear() supports more advanced options</para>
+    /// </summary>
+    /// <param name="coordinatesProperty">The property where 2DCoordinates are stored</param>
+    /// <param name="nearCoordinates">The search point</param>
+    /// <param name="maxDistance">Maximum distance in meters from the search point</param>
+    /// <param name="minDistance">Minimum distance in meters from the search point</param>
+    public TSelf Match(Expression<Func<T, object>> coordinatesProperty, Coordinates2D nearCoordinates, double? maxDistance = null, double? minDistance = null)
+    {
+        return Match(f => f.Near(coordinatesProperty, nearCoordinates.ToGeoJsonPoint(), maxDistance, minDistance));
+    }
 
-        /// <summary>
-        /// Specify the matching criteria with an aggregation expression (i.e. $expr)
-        /// </summary>
-        /// <param name="expression">{ $gt: ['$Property1', '$Property2'] }</param>
-        public TSelf MatchExpression(string expression)
-        {
-            _filter &= "{$expr:" + expression + "}";
-            return This;
-        }
+    /// <summary>
+    /// Specify the matching criteria with an aggregation expression (i.e. $expr)
+    /// </summary>
+    /// <param name="expression">{ $gt: ['$Property1', '$Property2'] }</param>
+    public TSelf MatchExpression(string expression)
+    {
+        _filter &= "{$expr:" + expression + "}";
+        return This;
+    }
 
-        /// <summary>
-        /// Specify the matching criteria with a Template
-        /// </summary>
-        /// <param name="template">A Template object</param>
-        public TSelf MatchExpression(Template template)
-        {
-            return MatchExpression(template.RenderToString());
-        }
+    /// <summary>
+    /// Specify the matching criteria with a Template
+    /// </summary>
+    /// <param name="template">A Template object</param>
+    public TSelf MatchExpression(Template template)
+    {
+        return MatchExpression(template.RenderToString());
+    }
 
-        /// <summary>
-        /// Specify an IEntity ID as the matching criteria
-        /// </summary>
-        /// <param name="ID">A unique IEntity ID</param>
-        public TSelf MatchID(string ID)
-        {
-            return Match(f => f.Eq(t => t.ID, ID));
-        }
+    /// <summary>
+    /// Specify an IEntity ID as the matching criteria
+    /// </summary>
+    /// <param name="ID">A unique IEntity ID</param>
+    public TSelf MatchID(TId ID)
+    {
+        return Match(f => f.Eq(t => t.ID, ID));
+    }
 
-        /// <summary>
-        /// Specify the matching criteria with a JSON string
-        /// </summary>
-        /// <param name="jsonString">{ Title : 'The Power Of Now' }</param>
-        public TSelf MatchString(string jsonString)
-        {
-            _filter &= jsonString;
-            return This;
-        }
+    /// <summary>
+    /// Specify the matching criteria with a JSON string
+    /// </summary>
+    /// <param name="jsonString">{ Title : 'The Power Of Now' }</param>
+    public TSelf MatchString(string jsonString)
+    {
+        _filter &= jsonString;
+        return This;
     }
 }
diff --git a/MongoDB.Entities/Builders/Find.cs b/MongoDB.Entities/Builders/Find.cs
index cd51a3335..f77d73f67 100644
--- a/MongoDB.Entities/Builders/Find.cs
+++ b/MongoDB.Entities/Builders/Find.cs
@@ -1,319 +1,317 @@
-using MongoDB.Bson;
-using MongoDB.Bson.Serialization;
-using MongoDB.Driver;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Linq.Expressions;
-using System.Threading;
-using System.Threading.Tasks;
-#nullable enable
-namespace MongoDB.Entities
-{
-    public abstract class FindBase<T, TProjection, TSelf> : SortFilterQueryBase<T, TSelf> where T : IEntity where TSelf : FindBase<T, TProjection, TSelf>
-    {
-        internal FindOptions<T, TProjection> _options = new();
-
-        internal FindBase(FindBase<T, TProjection, TSelf> other) : base(other)
-        {
-            _options = other._options;
-        }
-        internal FindBase(Dictionary<Type, (object filterDef, bool prepend)> globalFilters) : base(globalFilters: globalFilters)
-        {
-            _globalFilters = globalFilters;
-        }
-        public abstract DBContext Context { get; }
-        private TSelf This => (TSelf)this;
-
-        /// <summary>
-        /// Specify how many entities to skip
-        /// </summary>
-        /// <param name="skipCount">The number to skip</param>
-        public TSelf Skip(int skipCount)
-        {
-            _options.Skip = skipCount;
-            return This;
-        }
+namespace MongoDB.Entities;
 
-        /// <summary>
-        /// Specify how many entities to Take/Limit
-        /// </summary>
-        /// <param name="takeCount">The number to limit/take</param>
-        public TSelf Limit(int takeCount)
-        {
-            _options.Limit = takeCount;
-            return This;
-        }
+public abstract class FindBase<T, TId, TProjection, TSelf> : SortFilterQueryBase<T, TId, TSelf>
+    where TId : IComparable<TId>, IEquatable<TId>
+    where T : IEntity<TId>
+    where TSelf : FindBase<T, TId, TProjection, TSelf>
+{
+    internal FindOptions<T, TProjection> _options = new();
 
-        /// <summary>
-        /// Specify how to project the results using a lambda expression
-        /// </summary>
-        /// <param name="expression">x => new Test { PropName = x.Prop }</param>
-        public TSelf Project(Expression<Func<T, TProjection>> expression)
-        {
-            return Project(p => p.Expression(expression));
-        }
+    internal FindBase(FindBase<T, TId, TProjection, TSelf> other) : base(other)
+    {
+        _options = other._options;
+    }
+    internal FindBase(Dictionary<Type, (object filterDef, bool prepend)> globalFilters) : base(globalFilters: globalFilters)
+    {
+        _globalFilters = globalFilters;
+    }
+    public abstract DBContext Context { get; }
+    private TSelf This => (TSelf)this;
 
-        /// <summary>
-        /// Specify how to project the results using a projection expression
-        /// </summary>
-        /// <param name="projection">p => p.Include("Prop1").Exclude("Prop2")</param>
-        public TSelf Project(Func<ProjectionDefinitionBuilder<T>, ProjectionDefinition<T, TProjection>> projection)
-        {
-            _options.Projection = projection(Builders<T>.Projection);
-            return This;
-        }
+    /// <summary>
+    /// Specify how many entities to skip
+    /// </summary>
+    /// <param name="skipCount">The number to skip</param>
+    public TSelf Skip(int skipCount)
+    {
+        _options.Skip = skipCount;
+        return This;
+    }
 
-        /// <summary>
-        /// Specify to automatically include all properties marked with [BsonRequired] attribute on the entity in the final projection.
-        /// <para>HINT: this method should only be called after the .Project() method.</para>
-        /// </summary>
-        public TSelf IncludeRequiredProps()
-        {
-            if (typeof(T) != typeof(TProjection))
-                throw new InvalidOperationException("IncludeRequiredProps() cannot be used when projecting to a different type.");
+    /// <summary>
+    /// Specify how many entities to Take/Limit
+    /// </summary>
+    /// <param name="takeCount">The number to limit/take</param>
+    public TSelf Limit(int takeCount)
+    {
+        _options.Limit = takeCount;
+        return This;
+    }
 
-            _options.Projection = Context.Cache<T>().CombineWithRequiredProps(_options.Projection);
-            return This;
-        }
+    /// <summary>
+    /// Specify how to project the results using a lambda expression
+    /// </summary>
+    /// <param name="expression">x => new Test { PropName = x.Prop }</param>
+    public TSelf Project(Expression<Func<T, TProjection>> expression)
+    {
+        return Project(p => p.Expression(expression));
+    }
 
-        /// <summary>
-        /// Specify how to project the results using an exclusion projection expression.
-        /// </summary>
-        /// <param name="exclusion">x => new { x.PropToExclude, x.AnotherPropToExclude }</param>
-        public TSelf ProjectExcluding(Expression<Func<T, object>> exclusion)
-        {
-            var props = (exclusion.Body as NewExpression)?.Arguments
-                .Select(a => a.ToString().Split('.')[1]);
+    /// <summary>
+    /// Specify how to project the results using a projection expression
+    /// </summary>
+    /// <param name="projection">p => p.Include("Prop1").Exclude("Prop2")</param>
+    public TSelf Project(Func<ProjectionDefinitionBuilder<T>, ProjectionDefinition<T, TProjection>> projection)
+    {
+        _options.Projection = projection(Builders<T>.Projection);
+        return This;
+    }
 
-            if (props == null || !props.Any())
-                throw new ArgumentException("Unable to get any properties from the exclusion expression!");
+    /// <summary>
+    /// Specify to automatically include all properties marked with [BsonRequired] attribute on the entity in the final projection.
+    /// <para>HINT: this method should only be called after the .Project() method.</para>
+    /// </summary>
+    public TSelf IncludeRequiredProps()
+    {
+        if (typeof(T) != typeof(TProjection))
+            throw new InvalidOperationException("IncludeRequiredProps() cannot be used when projecting to a different type.");
 
-            var defs = new List<ProjectionDefinition<T>>(props.Count());
+        _options.Projection = Context.Cache<T>().CombineWithRequiredProps(_options.Projection);
+        return This;
+    }
 
-            foreach (var prop in props)
-            {
-                defs.Add(Builders<T>.Projection.Exclude(prop));
-            }
+    /// <summary>
+    /// Specify how to project the results using an exclusion projection expression.
+    /// </summary>
+    /// <param name="exclusion">x => new { x.PropToExclude, x.AnotherPropToExclude }</param>
+    public TSelf ProjectExcluding(Expression<Func<T, object>> exclusion)
+    {
+        var props = (exclusion.Body as NewExpression)?.Arguments
+            .Select(a => a.ToString().Split('.')[1]);
 
-            _options.Projection = Builders<T>.Projection.Combine(defs);
+        if (props == null || !props.Any())
+            throw new ArgumentException("Unable to get any properties from the exclusion expression!");
 
-            return This;
-        }
+        var defs = new List<ProjectionDefinition<T>>(props.Count());
 
-        /// <summary>
-        /// Specify an option for this find command (use multiple times if needed)
-        /// </summary>
-        /// <param name="option">x => x.OptionName = OptionValue</param>
-        public TSelf Option(Action<FindOptions<T, TProjection>> option)
+        foreach (var prop in props)
         {
-            option(_options);
-            return This;
+            defs.Add(Builders<T>.Projection.Exclude(prop));
         }
 
-        private void AddTxtScoreToProjection(string propName)
-        {
-            if (_options.Projection == null) _options.Projection = "{}";
+        _options.Projection = Builders<T>.Projection.Combine(defs);
 
-            _options.Projection =
-                _options.Projection
-                .Render(BsonSerializer.SerializerRegistry.GetSerializer<T>(), BsonSerializer.SerializerRegistry)
-                .Document.Add(propName, new BsonDocument { { "$meta", "textScore" } });
-        }
+        return This;
+    }
 
-        /// <summary>
-        /// Sort the results of a text search by the MetaTextScore
-        /// <para>TIP: Use this method after .Project() if you need to do a projection also</para>
-        /// </summary>
-        public TSelf SortByTextScore()
-        {
-            return SortByTextScore(null);
-        }
+    /// <summary>
+    /// Specify an option for this find command (use multiple times if needed)
+    /// </summary>
+    /// <param name="option">x => x.OptionName = OptionValue</param>
+    public TSelf Option(Action<FindOptions<T, TProjection>> option)
+    {
+        option(_options);
+        return This;
+    }
 
-        /// <summary>
-        /// Sort the results of a text search by the MetaTextScore and get back the score as well
-        /// <para>TIP: Use this method after .Project() if you need to do a projection also</para>
-        /// </summary>
-        /// <param name="scoreProperty">x => x.TextScoreProp</param>
-        public TSelf SortByTextScore(Expression<Func<T, object>>? scoreProperty)
-        {
-            switch (scoreProperty)
-            {
-                case null:
-                    AddTxtScoreToProjection("_Text_Match_Score_");
-                    return Sort(s => s.MetaTextScore("_Text_Match_Score_"));
+    private void AddTxtScoreToProjection(string propName)
+    {
+        if (_options.Projection == null) _options.Projection = "{}";
 
-                default:
-                    AddTxtScoreToProjection(Prop.Path(scoreProperty));
-                    return Sort(s => s.MetaTextScore(Prop.Path(scoreProperty)));
-            }
-        }
+        _options.Projection =
+            _options.Projection
+            .Render(BsonSerializer.SerializerRegistry.GetSerializer<T>(), BsonSerializer.SerializerRegistry)
+            .Document.Add(propName, new BsonDocument { { "$meta", "textScore" } });
     }
 
     /// <summary>
-    /// Represents a MongoDB Find command.
-    /// <para>TIP: Specify your criteria using .Match() .Sort() .Skip() .Take() .Project() .Option() methods and finally call .Execute()</para>
-    /// <para>Note: For building queries, use the DB.Fluent* interfaces</para>
+    /// Sort the results of a text search by the MetaTextScore
+    /// <para>TIP: Use this method after .Project() if you need to do a projection also</para>
     /// </summary>
-    /// <typeparam name="T">Any class that implements IEntity</typeparam>
-    public class Find<T> : Find<T, T> where T : IEntity
+    public TSelf SortByTextScore()
     {
-        internal Find(DBContext context, IMongoCollection<T> collection)
-            : base(context, collection) { }
-
-        internal Find(DBContext context, IMongoCollection<T> collection, FindBase<T, T, Find<T, T>> baseQuery)
-            : base(context, collection, baseQuery) { }
+        return SortByTextScore(null);
     }
 
-
     /// <summary>
-    /// Represents a MongoDB Find command with the ability to project to a different result type.
-    /// <para>TIP: Specify your criteria using .Match() .Sort() .Skip() .Take() .Project() .Option() methods and finally call .Execute()</para>
+    /// Sort the results of a text search by the MetaTextScore and get back the score as well
+    /// <para>TIP: Use this method after .Project() if you need to do a projection also</para>
     /// </summary>
-    /// <typeparam name="T">Any class that implements IEntity</typeparam>
-    /// <typeparam name="TProjection">The type you'd like to project the results to.</typeparam>
-    public class Find<T, TProjection> : FindBase<T, TProjection, Find<T, TProjection>>, ICollectionRelated<T> where T : IEntity
+    /// <param name="scoreProperty">x => x.TextScoreProp</param>
+    public TSelf SortByTextScore(Expression<Func<T, object>>? scoreProperty)
     {
-
-        /// <summary>
-        /// copy constructor
-        /// </summary>
-        /// <param name="other"></param>
-        /// <param name="context"></param>
-        /// <param name="collection"></param>
-        internal Find(DBContext context, IMongoCollection<T> collection, FindBase<T, TProjection, Find<T, TProjection>> other) : base(other)
-        {
-            Context = context;
-            Collection = collection;
-        }
-        internal Find(DBContext context, IMongoCollection<T> collection) : base(context.GlobalFilters)
+        switch (scoreProperty)
         {
-            Context = context;
-            Collection = collection;
+            case null:
+                AddTxtScoreToProjection("_Text_Match_Score_");
+                return Sort(s => s.MetaTextScore("_Text_Match_Score_"));
+
+            default:
+                AddTxtScoreToProjection(Prop.Path(scoreProperty));
+                return Sort(s => s.MetaTextScore(Prop.Path(scoreProperty)));
         }
+    }
+}
 
-        public override DBContext Context { get; }
-        public IMongoCollection<T> Collection { get; private set; }
+/// <summary>
+/// Represents a MongoDB Find command.
+/// <para>TIP: Specify your criteria using .Match() .Sort() .Skip() .Take() .Project() .Option() methods and finally call .Execute()</para>
+/// <para>Note: For building queries, use the DB.Fluent* interfaces</para>
+/// </summary>
+/// <typeparam name="T">Any class that implements IEntity</typeparam>
+/// <typeparam name="TId">Id type</typeparam>
+public class Find<T, TId> : Find<T, TId, T>
+    where TId : IComparable<TId>, IEquatable<TId>
+    where T : IEntity<TId>
+{
+    internal Find(DBContext context, IMongoCollection<T> collection)
+        : base(context, collection) { }
 
+    internal Find(DBContext context, IMongoCollection<T> collection, FindBase<T, TId, T, Find<T, TId, T>> baseQuery)
+        : base(context, collection, baseQuery) { }
+}
 
 
-        /// <summary>
-        /// Find a single IEntity by ID
-        /// </summary>
-        /// <param name="ID">The unique ID of an IEntity</param>
-        /// <param name="cancellation">An optional cancellation token</param>
-        /// <returns>A single entity or null if not found</returns>
-        public Task<TProjection> OneAsync(string ID, CancellationToken cancellation = default)
-        {
-            Match(ID);
-            return ExecuteSingleAsync(cancellation);
-        }
+/// <summary>
+/// Represents a MongoDB Find command with the ability to project to a different result type.
+/// <para>TIP: Specify your criteria using .Match() .Sort() .Skip() .Take() .Project() .Option() methods and finally call .Execute()</para>
+/// </summary>
+/// <typeparam name="T">Any class that implements IEntity</typeparam>
+/// <typeparam name="TId">ID type</typeparam>
+/// <typeparam name="TProjection">The type you'd like to project the results to.</typeparam>
+public class Find<T, TId, TProjection> : FindBase<T, TId, TProjection, Find<T, TId, TProjection>>, ICollectionRelated<T>
+    where TId : IComparable<TId>, IEquatable<TId>
+    where T : IEntity<TId>
+{
 
-        /// <summary>
-        /// Find entities by supplying a lambda expression
-        /// </summary>
-        /// <param name="expression">x => x.Property == Value</param>
-        /// <param name="cancellation">An optional cancellation token</param>
-        /// <returns>A list of Entities</returns>
-        public Task<List<TProjection>> ManyAsync(Expression<Func<T, bool>> expression, CancellationToken cancellation = default)
-        {
-            Match(expression);
-            return ExecuteAsync(cancellation);
-        }
+    /// <summary>
+    /// copy constructor
+    /// </summary>
+    /// <param name="other"></param>
+    /// <param name="context"></param>
+    /// <param name="collection"></param>
+    internal Find(DBContext context, IMongoCollection<T> collection, FindBase<T, TId, TProjection, Find<T, TId, TProjection>> other) : base(other)
+    {
+        Context = context;
+        Collection = collection;
+    }
+    internal Find(DBContext context, IMongoCollection<T> collection) : base(context.GlobalFilters)
+    {
+        Context = context;
+        Collection = collection;
+    }
 
-        /// <summary>
-        /// Find entities by supplying a filter expression
-        /// </summary>
-        /// <param name="filter">f => f.Eq(x => x.Prop, Value) &amp; f.Gt(x => x.Prop, Value)</param>
-        /// <param name="cancellation">An optional cancellation token</param>
-        /// <returns>A list of Entities</returns>
-        public Task<List<TProjection>> ManyAsync(Func<FilterDefinitionBuilder<T>, FilterDefinition<T>> filter, CancellationToken cancellation = default)
-        {
-            Match(filter);
-            return ExecuteAsync(cancellation);
-        }
+    public override DBContext Context { get; }
+    public IMongoCollection<T> Collection { get; private set; }
 
-        /// <summary>
-        /// Run the Find command in MongoDB server and get a list of results
-        /// </summary>
-        /// <param name="cancellation">An optional cancellation token</param>
-        public async Task<List<TProjection>> ExecuteAsync(CancellationToken cancellation = default)
-        {
-            var list = new List<TProjection>();
-            using (var cursor = await ExecuteCursorAsync(cancellation).ConfigureAwait(false))
-            {
-                while (await cursor.MoveNextAsync(cancellation).ConfigureAwait(false))
-                {
-                    list.AddRange(cursor.Current);
-                }
-            }
-            return list;
-        }
 
-        /// <summary>
-        /// Run the Find command in MongoDB server and get a single result or the default value if not found.
-        /// If more than one entity is found, it will throw an exception.
-        /// </summary>
-        /// <param name="cancellation">An optional cancellation token</param>
-        public async Task<TProjection> ExecuteSingleAsync(CancellationToken cancellation = default)
-        {
-            Limit(2);
-            using var cursor = await ExecuteCursorAsync(cancellation).ConfigureAwait(false);
-            await cursor.MoveNextAsync(cancellation).ConfigureAwait(false);
-            return cursor.Current.SingleOrDefault();
-        }
 
-        /// <summary>
-        /// Run the Find command in MongoDB server and get the first result or the default value if not found
-        /// </summary>
-        /// <param name="cancellation">An optional cancellation token</param>
-        public async Task<TProjection> ExecuteFirstAsync(CancellationToken cancellation = default)
-        {
-            Limit(1);
-            using var cursor = await ExecuteCursorAsync(cancellation).ConfigureAwait(false);
-            await cursor.MoveNextAsync(cancellation).ConfigureAwait(false);
-            return cursor.Current.SingleOrDefault(); //because we're limiting to 1
-        }
+    /// <summary>
+    /// Find a single IEntity by ID
+    /// </summary>
+    /// <param name="ID">The unique ID of an IEntity</param>
+    /// <param name="cancellation">An optional cancellation token</param>
+    /// <returns>A single entity or null if not found</returns>
+    public Task<TProjection> OneAsync(TId ID, CancellationToken cancellation = default)
+    {
+        Match(ID);
+        return ExecuteSingleAsync(cancellation);
+    }
 
-        /// <summary>
-        /// Run the Find command and get back a bool indicating whether any entities matched the query
-        /// </summary>
-        /// <param name="cancellation">An optional cancellation token</param>
-        public async Task<bool> ExecuteAnyAsync(CancellationToken cancellation = default)
-        {
-            Project(b => b.Include(x => x.ID));
-            Limit(1);
-            using var cursor = await ExecuteCursorAsync(cancellation).ConfigureAwait(false);
-            await cursor.MoveNextAsync(cancellation).ConfigureAwait(false);
-            return cursor.Current.Any();
-        }
+    /// <summary>
+    /// Find entities by supplying a lambda expression
+    /// </summary>
+    /// <param name="expression">x => x.Property == Value</param>
+    /// <param name="cancellation">An optional cancellation token</param>
+    /// <returns>A list of Entities</returns>
+    public Task<List<TProjection>> ManyAsync(Expression<Func<T, bool>> expression, CancellationToken cancellation = default)
+    {
+        Match(expression);
+        return ExecuteAsync(cancellation);
+    }
 
-        /// <summary>
-        /// Run the Find command in MongoDB server and get a cursor instead of materialized results
-        /// </summary>
-        /// <param name="cancellation">An optional cancellation token</param>
-        public Task<IAsyncCursor<TProjection>> ExecuteCursorAsync(CancellationToken cancellation = default)
+    /// <summary>
+    /// Find entities by supplying a filter expression
+    /// </summary>
+    /// <param name="filter">f => f.Eq(x => x.Prop, Value) &amp; f.Gt(x => x.Prop, Value)</param>
+    /// <param name="cancellation">An optional cancellation token</param>
+    /// <returns>A list of Entities</returns>
+    public Task<List<TProjection>> ManyAsync(Func<FilterDefinitionBuilder<T>, FilterDefinition<T>> filter, CancellationToken cancellation = default)
+    {
+        Match(filter);
+        return ExecuteAsync(cancellation);
+    }
+
+    /// <summary>
+    /// Run the Find command in MongoDB server and get a list of results
+    /// </summary>
+    /// <param name="cancellation">An optional cancellation token</param>
+    public async Task<List<TProjection>> ExecuteAsync(CancellationToken cancellation = default)
+    {
+        var list = new List<TProjection>();
+        using (var cursor = await ExecuteCursorAsync(cancellation).ConfigureAwait(false))
         {
-            if (_sorts.Count > 0)
-                _options.Sort = Builders<T>.Sort.Combine(_sorts);
+            while (await cursor.MoveNextAsync(cancellation).ConfigureAwait(false))
+            {
+                list.AddRange(cursor.Current);
+            }
+        }
+        return list;
+    }
 
-            var mergedFilter = Logic.MergeWithGlobalFilter(_ignoreGlobalFilters, _globalFilters, _filter);
+    /// <summary>
+    /// Run the Find command in MongoDB server and get a single result or the default value if not found.
+    /// If more than one entity is found, it will throw an exception.
+    /// </summary>
+    /// <param name="cancellation">An optional cancellation token</param>
+    public async Task<TProjection> ExecuteSingleAsync(CancellationToken cancellation = default)
+    {
+        Limit(2);
+        using var cursor = await ExecuteCursorAsync(cancellation).ConfigureAwait(false);
+        await cursor.MoveNextAsync(cancellation).ConfigureAwait(false);
+        return cursor.Current.SingleOrDefault();
+    }
 
-            return this.Session() is not IClientSessionHandle session ?
-                Collection.FindAsync(mergedFilter, _options, cancellation) :
-                Collection.FindAsync(session, mergedFilter, _options, cancellation);
-        }
+    /// <summary>
+    /// Run the Find command in MongoDB server and get the first result or the default value if not found
+    /// </summary>
+    /// <param name="cancellation">An optional cancellation token</param>
+    public async Task<TProjection> ExecuteFirstAsync(CancellationToken cancellation = default)
+    {
+        Limit(1);
+        using var cursor = await ExecuteCursorAsync(cancellation).ConfigureAwait(false);
+        await cursor.MoveNextAsync(cancellation).ConfigureAwait(false);
+        return cursor.Current.SingleOrDefault(); //because we're limiting to 1
     }
 
-    public enum Order
+    /// <summary>
+    /// Run the Find command and get back a bool indicating whether any entities matched the query
+    /// </summary>
+    /// <param name="cancellation">An optional cancellation token</param>
+    public async Task<bool> ExecuteAnyAsync(CancellationToken cancellation = default)
     {
-        Ascending,
-        Descending
+        Project(b => b.Include(x => x.ID));
+        Limit(1);
+        using var cursor = await ExecuteCursorAsync(cancellation).ConfigureAwait(false);
+        await cursor.MoveNextAsync(cancellation).ConfigureAwait(false);
+        return cursor.Current.Any();
     }
 
-    public enum Search
+    /// <summary>
+    /// Run the Find command in MongoDB server and get a cursor instead of materialized results
+    /// </summary>
+    /// <param name="cancellation">An optional cancellation token</param>
+    public Task<IAsyncCursor<TProjection>> ExecuteCursorAsync(CancellationToken cancellation = default)
     {
-        Fuzzy,
-        Full
+        if (_sorts.Count > 0)
+            _options.Sort = Builders<T>.Sort.Combine(_sorts);
+
+        var mergedFilter = Logic.MergeWithGlobalFilter(_ignoreGlobalFilters, _globalFilters, _filter);
+
+        return this.Session() is not IClientSessionHandle session ?
+            Collection.FindAsync(mergedFilter, _options, cancellation) :
+            Collection.FindAsync(session, mergedFilter, _options, cancellation);
     }
 }
+
+public enum Order
+{
+    Ascending,
+    Descending
+}
+
+public enum Search
+{
+    Fuzzy,
+    Full
+}
diff --git a/MongoDB.Entities/Builders/ICollectionRelated.cs b/MongoDB.Entities/Builders/ICollectionRelated.cs
index 5ca08ca05..4a31b2ce5 100644
--- a/MongoDB.Entities/Builders/ICollectionRelated.cs
+++ b/MongoDB.Entities/Builders/ICollectionRelated.cs
@@ -1,21 +1,15 @@
-using MongoDB.Driver;
-using System;
-using System.Collections.Generic;
-using System.Text;
-#nullable enable
-namespace MongoDB.Entities
+namespace MongoDB.Entities;
+
+internal interface ICollectionRelated<T>
+{
+    public DBContext Context { get; }
+    public IMongoCollection<T> Collection { get; }
+}
+internal static class ICollectionRelatedExt
 {
-    internal interface ICollectionRelated<T> where T : IEntity
+    public static IClientSessionHandle? Session<T>(this ICollectionRelated<T> collectionRelated)
     {
-        public DBContext Context { get; }
-        public IMongoCollection<T> Collection { get; }
+        return collectionRelated.Context.Session;
     }
-    internal static class ICollectionRelatedExt
-    {
-        public static IClientSessionHandle? Session<T>(this ICollectionRelated<T> collectionRelated) where T : IEntity
-        {
-            return collectionRelated.Context.Session;
-        }
 
-    }
 }
diff --git a/MongoDB.Entities/Builders/Index.cs b/MongoDB.Entities/Builders/Index.cs
index 3ed2209b6..0e1fbf1ca 100644
--- a/MongoDB.Entities/Builders/Index.cs
+++ b/MongoDB.Entities/Builders/Index.cs
@@ -1,191 +1,188 @@
-using MongoDB.Driver;
-using System;
-using System.Collections.Generic;
-using System.Linq.Expressions;
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace MongoDB.Entities
+namespace MongoDB.Entities;
+
+/// <summary>
+/// Represents an index creation command
+/// <para>TIP: Define the keys first with .Key() method and finally call the .Create() method.</para>
+/// </summary>
+/// <typeparam name="T">Any class that implements IEntity</typeparam>
+/// <typeparam name="TId">Id type</typeparam>
+public class Index<T, TId> : ICollectionRelated<T>
+            where TId : IComparable<TId>, IEquatable<TId>
+    where T : IEntity<TId>
 {
+    internal List<Key<T, TId>> Keys { get; set; } = new();
+    public DBContext Context { get; }
+    public IMongoCollection<T> Collection { get; }
+
+    private readonly CreateIndexOptions<T> _options = new() { Background = true };
+
+    internal Index(DBContext context, IMongoCollection<T> collection)
+    {
+        Context = context;
+        Collection = collection;
+    }
+
     /// <summary>
-    /// Represents an index creation command
-    /// <para>TIP: Define the keys first with .Key() method and finally call the .Create() method.</para>
+    /// Call this method to finalize defining the index after setting the index keys and options.
     /// </summary>
-    /// <typeparam name="T">Any class that implements IEntity</typeparam>
-    public class Index<T> : ICollectionRelated<T> where T : IEntity
+    /// <param name="cancellation">An optional cancellation token</param>
+    /// <returns>The name of the created index</returns>
+    public async Task<string> CreateAsync(CancellationToken cancellation = default)
     {
-        internal List<Key<T>> Keys { get; set; } = new List<Key<T>>();
-        public DBContext Context { get; }
-        public IMongoCollection<T> Collection { get; }
-
-        private readonly CreateIndexOptions<T> _options = new() { Background = true };
+        if (Keys.Count == 0) throw new ArgumentException("Please define keys before calling this method.");
 
-        internal Index(DBContext context, IMongoCollection<T> collection)
-        {
-            Context = context;
-            Collection = collection;
-        }
+        var propNames = new List<string>();
+        var keyDefs = new List<IndexKeysDefinition<T>>();
+        var isTextIndex = false;
 
-        /// <summary>
-        /// Call this method to finalize defining the index after setting the index keys and options.
-        /// </summary>
-        /// <param name="cancellation">An optional cancellation token</param>
-        /// <returns>The name of the created index</returns>
-        public async Task<string> CreateAsync(CancellationToken cancellation = default)
+        foreach (var key in Keys)
         {
-            if (Keys.Count == 0) throw new ArgumentException("Please define keys before calling this method.");
-
-            var propNames = new List<string>();
-            var keyDefs = new List<IndexKeysDefinition<T>>();
-            var isTextIndex = false;
-
-            foreach (var key in Keys)
-            {
-                string keyType = string.Empty;
-
-                switch (key.Type)
-                {
-                    case KeyType.Ascending:
-                        keyDefs.Add(Builders<T>.IndexKeys.Ascending(key.PropertyName));
-                        keyType = "(Asc)";
-                        break;
-                    case KeyType.Descending:
-                        keyDefs.Add(Builders<T>.IndexKeys.Descending(key.PropertyName));
-                        keyType = "(Dsc)";
-                        break;
-                    case KeyType.Geo2D:
-                        keyDefs.Add(Builders<T>.IndexKeys.Geo2D(key.PropertyName));
-                        keyType = "(G2d)";
-                        break;
-                    case KeyType.Geo2DSphere:
-                        keyDefs.Add(Builders<T>.IndexKeys.Geo2DSphere(key.PropertyName));
-                        keyType = "(Gsp)";
-                        break;
-                    case KeyType.Hashed:
-                        keyDefs.Add(Builders<T>.IndexKeys.Hashed(key.PropertyName));
-                        keyType = "(Hsh)";
-                        break;
-                    case KeyType.Text:
-                        keyDefs.Add(Builders<T>.IndexKeys.Text(key.PropertyName));
-                        isTextIndex = true;
-                        break;
-                    case KeyType.Wildcard:
-                        keyDefs.Add(Builders<T>.IndexKeys.Wildcard(key.PropertyName));
-                        keyType = "(Wld)";
-                        break;
-                }
-                propNames.Add(key.PropertyName + keyType);
-            }
-
-            if (string.IsNullOrEmpty(_options.Name))
-            {
-                if (isTextIndex)
-                    _options.Name = "[TEXT]";
-                else
-                    _options.Name = string.Join(" | ", propNames);
-            }
+            string keyType = string.Empty;
 
-            var model = new CreateIndexModel<T>(
-                Builders<T>.IndexKeys.Combine(keyDefs),
-                _options);
-
-            try
-            {
-                await CreateAsync(model, cancellation).ConfigureAwait(false);
-            }
-            catch (MongoCommandException x) when (x.Code == 85 || x.Code == 86)
+            switch (key.Type)
             {
-                await DropAsync(_options.Name, cancellation).ConfigureAwait(false);
-                await CreateAsync(model, cancellation).ConfigureAwait(false);
+                case KeyType.Ascending:
+                    keyDefs.Add(Builders<T>.IndexKeys.Ascending(key.PropertyName));
+                    keyType = "(Asc)";
+                    break;
+                case KeyType.Descending:
+                    keyDefs.Add(Builders<T>.IndexKeys.Descending(key.PropertyName));
+                    keyType = "(Dsc)";
+                    break;
+                case KeyType.Geo2D:
+                    keyDefs.Add(Builders<T>.IndexKeys.Geo2D(key.PropertyName));
+                    keyType = "(G2d)";
+                    break;
+                case KeyType.Geo2DSphere:
+                    keyDefs.Add(Builders<T>.IndexKeys.Geo2DSphere(key.PropertyName));
+                    keyType = "(Gsp)";
+                    break;
+                case KeyType.Hashed:
+                    keyDefs.Add(Builders<T>.IndexKeys.Hashed(key.PropertyName));
+                    keyType = "(Hsh)";
+                    break;
+                case KeyType.Text:
+                    keyDefs.Add(Builders<T>.IndexKeys.Text(key.PropertyName));
+                    isTextIndex = true;
+                    break;
+                case KeyType.Wildcard:
+                    keyDefs.Add(Builders<T>.IndexKeys.Wildcard(key.PropertyName));
+                    keyType = "(Wld)";
+                    break;
             }
-
-            return _options.Name;
+            propNames.Add(key.PropertyName + keyType);
         }
 
-        /// <summary>
-        /// Set the options for this index definition
-        /// <para>TIP: Setting options is not required.</para>
-        /// </summary>
-        /// <param name="option">x => x.OptionName = OptionValue</param>
-        public Index<T> Option(Action<CreateIndexOptions<T>> option)
+        if (string.IsNullOrEmpty(_options.Name))
         {
-            option(_options);
-            return this;
+            if (isTextIndex)
+                _options.Name = "[TEXT]";
+            else
+                _options.Name = string.Join(" | ", propNames);
         }
 
-        /// <summary>
-        /// Adds a key definition to the index
-        /// <para>TIP: At least one key definition is required</para>
-        /// </summary>
-        /// <param name="propertyToIndex">x => x.PropertyName</param>
-        /// <param name="type">The type of the key</param>
-        public Index<T> Key(Expression<Func<T, object>> propertyToIndex, KeyType type)
-        {
-            Keys.Add(new Key<T>(propertyToIndex, type));
-            return this;
-        }
+        var model = new CreateIndexModel<T>(
+            Builders<T>.IndexKeys.Combine(keyDefs),
+            _options);
 
-        /// <summary>
-        /// Drops an index by name for this entity type
-        /// </summary>
-        /// <param name="name">The name of the index to drop</param>
-        /// <param name="cancellation">An optional cancellation token</param>
-        public async Task DropAsync(string name, CancellationToken cancellation = default)
+        try
         {
-            await Collection.Indexes.DropOneAsync(name, cancellation).ConfigureAwait(false);
+            await CreateAsync(model, cancellation).ConfigureAwait(false);
         }
-
-        /// <summary>
-        /// Drops all indexes for this entity type
-        /// </summary>
-        /// <param name="cancellation">An optional cancellation token</param>
-        public async Task DropAllAsync(CancellationToken cancellation = default)
+        catch (MongoCommandException x) when (x.Code == 85 || x.Code == 86)
         {
-            await Collection.Indexes.DropAllAsync(cancellation).ConfigureAwait(false);
+            await DropAsync(_options.Name, cancellation).ConfigureAwait(false);
+            await CreateAsync(model, cancellation).ConfigureAwait(false);
         }
 
-        private Task CreateAsync(CreateIndexModel<T> model, CancellationToken cancellation = default)
-        {
-            return Collection.Indexes.CreateOneAsync(model, cancellationToken: cancellation);
-        }
+        return _options.Name;
     }
 
-    internal class Key<T> where T : IEntity
+    /// <summary>
+    /// Set the options for this index definition
+    /// <para>TIP: Setting options is not required.</para>
+    /// </summary>
+    /// <param name="option">x => x.OptionName = OptionValue</param>
+    public Index<T, TId> Option(Action<CreateIndexOptions<T>> option)
     {
-        internal string PropertyName { get; set; }
-        internal KeyType Type { get; set; }
+        option(_options);
+        return this;
+    }
 
-        internal Key(Expression<Func<T, object>> expression, KeyType type)
-        {
-            Type = type;
+    /// <summary>
+    /// Adds a key definition to the index
+    /// <para>TIP: At least one key definition is required</para>
+    /// </summary>
+    /// <param name="propertyToIndex">x => x.PropertyName</param>
+    /// <param name="type">The type of the key</param>
+    public Index<T, TId> Key(Expression<Func<T, object>> propertyToIndex, KeyType type)
+    {
+        Keys.Add(new Key<T, TId>(propertyToIndex, type));
+        return this;
+    }
 
-            if (expression.Body.NodeType == ExpressionType.Parameter && type == KeyType.Text)
-            {
-                PropertyName = "$**";
-                return;
-            }
+    /// <summary>
+    /// Drops an index by name for this entity type
+    /// </summary>
+    /// <param name="name">The name of the index to drop</param>
+    /// <param name="cancellation">An optional cancellation token</param>
+    public async Task DropAsync(string name, CancellationToken cancellation = default)
+    {
+        await Collection.Indexes.DropOneAsync(name, cancellation).ConfigureAwait(false);
+    }
 
-            if (expression.Body.NodeType == ExpressionType.MemberAccess && type == KeyType.Text)
-            {
-                if (expression.PropertyInfo().PropertyType == typeof(FuzzyString))
-                    PropertyName = expression.FullPath() + ".Hash";
-                else
-                    PropertyName = expression.FullPath();
-                return;
-            }
+    /// <summary>
+    /// Drops all indexes for this entity type
+    /// </summary>
+    /// <param name="cancellation">An optional cancellation token</param>
+    public async Task DropAllAsync(CancellationToken cancellation = default)
+    {
+        await Collection.Indexes.DropAllAsync(cancellation).ConfigureAwait(false);
+    }
 
-            PropertyName = expression.FullPath();
-        }
+    private Task CreateAsync(CreateIndexModel<T> model, CancellationToken cancellation = default)
+    {
+        return Collection.Indexes.CreateOneAsync(model, cancellationToken: cancellation);
     }
+}
+
+internal class Key<T, TId>
+    where TId : IComparable<TId>, IEquatable<TId>
+    where T : IEntity<TId>
+{
+    internal string PropertyName { get; set; }
+    internal KeyType Type { get; set; }
 
-    public enum KeyType
+    internal Key(Expression<Func<T, object>> expression, KeyType type)
     {
-        Ascending,
-        Descending,
-        Geo2D,
-        Geo2DSphere,
-        Hashed,
-        Text,
-        Wildcard
+        Type = type;
+
+        if (expression.Body.NodeType == ExpressionType.Parameter && type == KeyType.Text)
+        {
+            PropertyName = "$**";
+            return;
+        }
+
+        if (expression.Body.NodeType == ExpressionType.MemberAccess && type == KeyType.Text)
+        {
+            if (expression.PropertyInfo().PropertyType == typeof(FuzzyString))
+                PropertyName = expression.FullPath() + ".Hash";
+            else
+                PropertyName = expression.FullPath();
+            return;
+        }
+
+        PropertyName = expression.FullPath();
     }
 }
+
+public enum KeyType
+{
+    Ascending,
+    Descending,
+    Geo2D,
+    Geo2DSphere,
+    Hashed,
+    Text,
+    Wildcard
+}
diff --git a/MongoDB.Entities/Builders/PagedSearch.cs b/MongoDB.Entities/Builders/PagedSearch.cs
index 760d4b24e..73a7f0bb5 100644
--- a/MongoDB.Entities/Builders/PagedSearch.cs
+++ b/MongoDB.Entities/Builders/PagedSearch.cs
@@ -1,269 +1,267 @@
-using MongoDB.Bson;
-using MongoDB.Bson.Serialization;
-using MongoDB.Driver;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Linq.Expressions;
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace MongoDB.Entities
+namespace MongoDB.Entities;
+
+public class PagedSearchBase<T, TId, TProjection, TSelf> : SortFilterQueryBase<T, TId, TSelf>
+    where TId : IComparable<TId>, IEquatable<TId>
+    where T : IEntity<TId>
+    where TSelf : PagedSearchBase<T, TId, TProjection, TSelf>
 {
-    public class PagedSearchBase<T, TProjection, TSelf> : SortFilterQueryBase<T, TSelf> where TSelf : PagedSearchBase<T, TProjection, TSelf> where T : IEntity
+    internal PagedSearchBase(PagedSearchBase<T, TId, TProjection, TSelf> other) : base(other)
     {
-        internal PagedSearchBase(PagedSearchBase<T, TProjection, TSelf> other) : base(other)
-        {
-        }
+    }
 
-        internal PagedSearchBase(Dictionary<Type, (object filterDef, bool prepend)> globalFilters) : base(globalFilters)
-        {
-        }
-        private TSelf This => (TSelf)this;
-
-        internal IAggregateFluent<T>? _fluentPipeline;
-        internal AggregateOptions _options = new();
-        internal PipelineStageDefinition<T, TProjection>? _projectionStage;
-        internal int _pageNumber = 1, _pageSize = 100;
-
-        /// <summary>
-        /// Begins the paged search aggregation pipeline with the provided fluent pipeline.
-        /// <para>TIP: This method must be first in the chain and it cannot be used with .Match()</para>
-        /// </summary>
-        /// <typeparam name="TFluent">The type of the input pipeline</typeparam>
-        /// <param name="fluentPipeline">The input IAggregateFluent pipeline</param>
-        public TSelf WithFluent<TFluent>(TFluent fluentPipeline) where TFluent : IAggregateFluent<T>
-        {
-            this._fluentPipeline = fluentPipeline;
-            return This;
-        }
+    internal PagedSearchBase(Dictionary<Type, (object filterDef, bool prepend)> globalFilters) : base(globalFilters)
+    {
+    }
+    private TSelf This => (TSelf)this;
 
+    internal IAggregateFluent<T>? _fluentPipeline;
+    internal AggregateOptions _options = new();
+    internal PipelineStageDefinition<T, TProjection>? _projectionStage;
+    internal int _pageNumber = 1, _pageSize = 100;
 
+    /// <summary>
+    /// Begins the paged search aggregation pipeline with the provided fluent pipeline.
+    /// <para>TIP: This method must be first in the chain and it cannot be used with .Match()</para>
+    /// </summary>
+    /// <typeparam name="TFluent">The type of the input pipeline</typeparam>
+    /// <param name="fluentPipeline">The input IAggregateFluent pipeline</param>
+    public TSelf WithFluent<TFluent>(TFluent fluentPipeline) where TFluent : IAggregateFluent<T>
+    {
+        this._fluentPipeline = fluentPipeline;
+        return This;
+    }
 
 
 
-        /// <summary>
-        /// Sort the results of a text search by the MetaTextScore
-        /// <para>TIP: Use this method after .Project() if you need to do a projection also</para>
-        /// </summary>
-        public TSelf SortByTextScore()
-        {
-            return SortByTextScore(null);
-        }
 
-        /// <summary>
-        /// Sort the results of a text search by the MetaTextScore and get back the score as well
-        /// <para>TIP: Use this method after .Project() if you need to do a projection also</para>
-        /// </summary>
-        /// <param name="scoreProperty">x => x.TextScoreProp</param>
-        public TSelf SortByTextScore(Expression<Func<T, object>>? scoreProperty)
-        {
-            switch (scoreProperty)
-            {
-                case null:
-                    AddTxtScoreToProjection("_Text_Match_Score_");
-                    return Sort(s => s.MetaTextScore("_Text_Match_Score_"));
-
-                default:
-                    AddTxtScoreToProjection(Prop.Path(scoreProperty));
-                    return Sort(s => s.MetaTextScore(Prop.Path(scoreProperty)));
-            }
-        }
 
-        private void AddTxtScoreToProjection(string fieldName)
-        {
-            if (_projectionStage == null)
-            {
-                _projectionStage = $"{{ $set : {{ {fieldName} : {{ $meta : 'textScore' }}  }} }}";
-                return;
-            }
+    /// <summary>
+    /// Sort the results of a text search by the MetaTextScore
+    /// <para>TIP: Use this method after .Project() if you need to do a projection also</para>
+    /// </summary>
+    public TSelf SortByTextScore()
+    {
+        return SortByTextScore(null);
+    }
 
-            var renderedStage = _projectionStage.Render(
-                BsonSerializer.SerializerRegistry.GetSerializer<T>(),
-                BsonSerializer.SerializerRegistry);
+    /// <summary>
+    /// Sort the results of a text search by the MetaTextScore and get back the score as well
+    /// <para>TIP: Use this method after .Project() if you need to do a projection also</para>
+    /// </summary>
+    /// <param name="scoreProperty">x => x.TextScoreProp</param>
+    public TSelf SortByTextScore(Expression<Func<T, object>>? scoreProperty)
+    {
+        switch (scoreProperty)
+        {
+            case null:
+                AddTxtScoreToProjection("_Text_Match_Score_");
+                return Sort(s => s.MetaTextScore("_Text_Match_Score_"));
 
-            renderedStage.Document["$project"][fieldName] = new BsonDocument { { "$meta", "textScore" } };
+            default:
+                AddTxtScoreToProjection(Prop.Path(scoreProperty));
+                return Sort(s => s.MetaTextScore(Prop.Path(scoreProperty)));
+        }
+    }
 
-            _projectionStage = renderedStage.Document;
+    private void AddTxtScoreToProjection(string fieldName)
+    {
+        if (_projectionStage == null)
+        {
+            _projectionStage = $"{{ $set : {{ {fieldName} : {{ $meta : 'textScore' }}  }} }}";
+            return;
         }
 
+        var renderedStage = _projectionStage.Render(
+            BsonSerializer.SerializerRegistry.GetSerializer<T>(),
+            BsonSerializer.SerializerRegistry);
 
+        renderedStage.Document["$project"][fieldName] = new BsonDocument { { "$meta", "textScore" } };
 
-        /// <summary>
-        /// Specify the page number to get
-        /// </summary>
-        /// <param name="pageNumber">The page number</param>
-        public TSelf PageNumber(int pageNumber)
-        {
-            this._pageNumber = pageNumber;
-            return This;
-        }
+        _projectionStage = renderedStage.Document;
+    }
 
-        /// <summary>
-        /// Specify the number of items per page
-        /// </summary>
-        /// <param name="pageSize">The size of a page</param>
-        public TSelf PageSize(int pageSize)
-        {
-            this._pageSize = pageSize;
-            return This;
-        }
 
-        /// <summary>
-        /// Specify how to project the results using a lambda expression
-        /// </summary>
-        /// <param name="expression">x => new Test { PropName = x.Prop }</param>
-        public TSelf Project(Expression<Func<T, TProjection>> expression)
-        {
-            _projectionStage = PipelineStageDefinitionBuilder.Project(expression);
-            return This;
-        }
 
-        /// <summary>
-        /// Specify how to project the results using a projection expression
-        /// </summary>
-        /// <param name="projection">p => p.Include("Prop1").Exclude("Prop2")</param>
-        public TSelf Project(Func<ProjectionDefinitionBuilder<T>, ProjectionDefinition<T, TProjection>> projection)
-        {
-            _projectionStage = PipelineStageDefinitionBuilder.Project(projection(Builders<T>.Projection));
-            return This;
-        }
+    /// <summary>
+    /// Specify the page number to get
+    /// </summary>
+    /// <param name="pageNumber">The page number</param>
+    public TSelf PageNumber(int pageNumber)
+    {
+        this._pageNumber = pageNumber;
+        return This;
+    }
 
-        /// <summary>
-        /// Specify how to project the results using an exclusion projection expression.
-        /// </summary>
-        /// <param name="exclusion">x => new { x.PropToExclude, x.AnotherPropToExclude }</param>
-        public TSelf ProjectExcluding(Expression<Func<T, object>> exclusion)
-        {
-            var props = (exclusion.Body as NewExpression)?.Arguments
-                .Select(a => a.ToString().Split('.')[1]);
+    /// <summary>
+    /// Specify the number of items per page
+    /// </summary>
+    /// <param name="pageSize">The size of a page</param>
+    public TSelf PageSize(int pageSize)
+    {
+        this._pageSize = pageSize;
+        return This;
+    }
 
-            if (props == null || !props.Any())
-                throw new ArgumentException("Unable to get any properties from the exclusion expression!");
+    /// <summary>
+    /// Specify how to project the results using a lambda expression
+    /// </summary>
+    /// <param name="expression">x => new Test { PropName = x.Prop }</param>
+    public TSelf Project(Expression<Func<T, TProjection>> expression)
+    {
+        _projectionStage = PipelineStageDefinitionBuilder.Project(expression);
+        return This;
+    }
 
-            var defs = new List<ProjectionDefinition<T>>(props.Count());
+    /// <summary>
+    /// Specify how to project the results using a projection expression
+    /// </summary>
+    /// <param name="projection">p => p.Include("Prop1").Exclude("Prop2")</param>
+    public TSelf Project(Func<ProjectionDefinitionBuilder<T>, ProjectionDefinition<T, TProjection>> projection)
+    {
+        _projectionStage = PipelineStageDefinitionBuilder.Project(projection(Builders<T>.Projection));
+        return This;
+    }
 
-            foreach (var prop in props)
-            {
-                defs.Add(Builders<T>.Projection.Exclude(prop));
-            }
+    /// <summary>
+    /// Specify how to project the results using an exclusion projection expression.
+    /// </summary>
+    /// <param name="exclusion">x => new { x.PropToExclude, x.AnotherPropToExclude }</param>
+    public TSelf ProjectExcluding(Expression<Func<T, object>> exclusion)
+    {
+        var props = (exclusion.Body as NewExpression)?.Arguments
+            .Select(a => a.ToString().Split('.')[1]);
 
-            _projectionStage = PipelineStageDefinitionBuilder.Project<T, TProjection>(Builders<T>.Projection.Combine(defs));
+        if (props == null || !props.Any())
+            throw new ArgumentException("Unable to get any properties from the exclusion expression!");
 
-            return This;
-        }
+        var defs = new List<ProjectionDefinition<T>>(props.Count());
 
-        /// <summary>
-        /// Specify an option for this find command (use multiple times if needed)
-        /// </summary>
-        /// <param name="option">x => x.OptionName = OptionValue</param>
-        public TSelf Option(Action<AggregateOptions> option)
+        foreach (var prop in props)
         {
-            option(_options);
-            return This;
+            defs.Add(Builders<T>.Projection.Exclude(prop));
         }
 
+        _projectionStage = PipelineStageDefinitionBuilder.Project<T, TProjection>(Builders<T>.Projection.Combine(defs));
 
+        return This;
     }
 
     /// <summary>
-    /// Represents an aggregation query that retrieves results with easy paging support.
+    /// Specify an option for this find command (use multiple times if needed)
     /// </summary>
-    /// <typeparam name="T">Any class that implements IEntity</typeparam>
-    public class PagedSearch<T> : PagedSearch<T, T> where T : IEntity
+    /// <param name="option">x => x.OptionName = OptionValue</param>
+    public TSelf Option(Action<AggregateOptions> option)
     {
-        internal PagedSearch(
-            DBContext context, IMongoCollection<T> collection)
-        : base(context, collection) { }
+        option(_options);
+        return This;
     }
 
+
+}
+
+/// <summary>
+/// Represents an aggregation query that retrieves results with easy paging support.
+/// </summary>
+/// <typeparam name="T">Any class that implements IEntity</typeparam>
+/// <typeparam name="TId">Id type</typeparam>
+public class PagedSearch<T, TId> : PagedSearch<T, TId, T>
+    where TId : IComparable<TId>, IEquatable<TId>
+    where T : IEntity<TId>
+{
+    internal PagedSearch(
+        DBContext context, IMongoCollection<T> collection)
+    : base(context, collection) { }
+}
+
+/// <summary>
+/// Represents an aggregation query that retrieves results with easy paging support.
+/// </summary>
+/// <typeparam name="T">Any class that implements IEntity</typeparam>
+/// <typeparam name="TId">Id type</typeparam>
+/// <typeparam name="TProjection">The type you'd like to project the results to.</typeparam>
+public class PagedSearch<T, TId, TProjection> : PagedSearchBase<T, TId, TProjection, PagedSearch<T, TId, TProjection>>
+    where TId : IComparable<TId>, IEquatable<TId>
+    where T : IEntity<TId>
+{
+
+    public DBContext Context { get; set; }
+    public IMongoCollection<T> Collection { get; set; }
+
+    internal PagedSearch(DBContext context, IMongoCollection<T> collection) : base(context.GlobalFilters)
+    {
+        var type = typeof(TProjection);
+        if (type.IsPrimitive || type.IsValueType || (type == typeof(string)))
+            throw new NotSupportedException("Projecting to primitive types is not supported!");
+        Context = context;
+        Collection = collection;
+    }
+
+
+
     /// <summary>
-    /// Represents an aggregation query that retrieves results with easy paging support.
+    /// Run the aggregation search command in MongoDB server and get a page of results and total + page count
     /// </summary>
-    /// <typeparam name="T">Any class that implements IEntity</typeparam>
-    /// <typeparam name="TProjection">The type you'd like to project the results to.</typeparam>
-    public class PagedSearch<T, TProjection> : PagedSearchBase<T, TProjection, PagedSearch<T, TProjection>> where T : IEntity
+    /// <param name="cancellation">An optional cancellation token</param>
+    public async Task<(IReadOnlyList<TProjection> Results, long TotalCount, int PageCount)> ExecuteAsync(CancellationToken cancellation = default)
     {
+        if (_filter != Builders<T>.Filter.Empty && _fluentPipeline != null)
+            throw new InvalidOperationException(".Match() and .WithFluent() cannot be used together!");
 
-        public DBContext Context { get; set; }
-        public IMongoCollection<T> Collection { get; set; }
+        var pipelineStages = new List<IPipelineStageDefinition>(4);
 
-        internal PagedSearch(DBContext context, IMongoCollection<T> collection) : base(context.GlobalFilters)
-        {
-            var type = typeof(TProjection);
-            if (type.IsPrimitive || type.IsValueType || (type == typeof(string)))
-                throw new NotSupportedException("Projecting to primitive types is not supported!");
-            Context = context;
-            Collection = collection;
-        }
+        if (_sorts.Count == 0)
+            throw new InvalidOperationException("Paging without sorting is a sin!");
+        else
+            pipelineStages.Add(PipelineStageDefinitionBuilder.Sort(Builders<T>.Sort.Combine(_sorts)));
 
+        pipelineStages.Add(PipelineStageDefinitionBuilder.Skip<T>((_pageNumber - 1) * _pageSize));
+        pipelineStages.Add(PipelineStageDefinitionBuilder.Limit<T>(_pageSize));
 
+        if (_projectionStage != null)
+            pipelineStages.Add(_projectionStage);
 
-        /// <summary>
-        /// Run the aggregation search command in MongoDB server and get a page of results and total + page count
-        /// </summary>
-        /// <param name="cancellation">An optional cancellation token</param>
-        public async Task<(IReadOnlyList<TProjection> Results, long TotalCount, int PageCount)> ExecuteAsync(CancellationToken cancellation = default)
-        {
-            if (_filter != Builders<T>.Filter.Empty && _fluentPipeline != null)
-                throw new InvalidOperationException(".Match() and .WithFluent() cannot be used together!");
+        var resultsFacet = AggregateFacet.Create<T, TProjection>("_results", pipelineStages);
 
-            var pipelineStages = new List<IPipelineStageDefinition>(4);
+        var countFacet = AggregateFacet.Create("_count",
+            PipelineDefinition<T, AggregateCountResult>.Create(new[]
+            {
+                    PipelineStageDefinitionBuilder.Count<T>()
+            }));
 
-            if (_sorts.Count == 0)
-                throw new InvalidOperationException("Paging without sorting is a sin!");
-            else
-                pipelineStages.Add(PipelineStageDefinitionBuilder.Sort(Builders<T>.Sort.Combine(_sorts)));
+        AggregateFacetResults facetResult;
 
-            pipelineStages.Add(PipelineStageDefinitionBuilder.Skip<T>((_pageNumber - 1) * _pageSize));
-            pipelineStages.Add(PipelineStageDefinitionBuilder.Limit<T>(_pageSize));
+        if (_fluentPipeline == null) //.Match() used
+        {
+            var filterDef = Logic.MergeWithGlobalFilter(_ignoreGlobalFilters, _globalFilters, _filter);
 
-            if (_projectionStage != null)
-                pipelineStages.Add(_projectionStage);
+            facetResult =
+                Context.Session is not IClientSessionHandle session
+                ? await Collection.Aggregate(_options).Match(filterDef).Facet(countFacet, resultsFacet).SingleAsync(cancellation).ConfigureAwait(false)
+                : await Collection.Aggregate(session, _options).Match(filterDef).Facet(countFacet, resultsFacet).SingleAsync(cancellation).ConfigureAwait(false);
+        }
+        else //.WithFluent() used
+        {
+            facetResult = await _fluentPipeline
+                .Facet(countFacet, resultsFacet)
+                .SingleAsync(cancellation)
+                .ConfigureAwait(false);
+        }
 
-            var resultsFacet = AggregateFacet.Create<T, TProjection>("_results", pipelineStages);
+        long matchCount = (
+            facetResult.Facets
+                       .Single(x => x.Name == "_count")
+                       .Output<AggregateCountResult>().FirstOrDefault()?.Count
+        ) ?? 0;
 
-            var countFacet = AggregateFacet.Create("_count",
-                PipelineDefinition<T, AggregateCountResult>.Create(new[]
-                {
-                    PipelineStageDefinitionBuilder.Count<T>()
-                }));
+        int pageCount =
+             matchCount > 0 && matchCount <= _pageSize
+             ? 1
+             : (int)Math.Ceiling((double)matchCount / _pageSize);
 
-            AggregateFacetResults facetResult;
+        var results = facetResult.Facets
+            .First(x => x.Name == "_results")
+            .Output<TProjection>();
 
-            if (_fluentPipeline == null) //.Match() used
-            {
-                var filterDef = Logic.MergeWithGlobalFilter(_ignoreGlobalFilters, _globalFilters, _filter);
-
-                facetResult =
-                    Context.Session is not IClientSessionHandle session
-                    ? await Collection.Aggregate(_options).Match(filterDef).Facet(countFacet, resultsFacet).SingleAsync(cancellation).ConfigureAwait(false)
-                    : await Collection.Aggregate(session, _options).Match(filterDef).Facet(countFacet, resultsFacet).SingleAsync(cancellation).ConfigureAwait(false);
-            }
-            else //.WithFluent() used
-            {
-                facetResult = await _fluentPipeline
-                    .Facet(countFacet, resultsFacet)
-                    .SingleAsync(cancellation)
-                    .ConfigureAwait(false);
-            }
-
-            long matchCount = (
-                facetResult.Facets
-                           .Single(x => x.Name == "_count")
-                           .Output<AggregateCountResult>().FirstOrDefault()?.Count
-            ) ?? 0;
-
-            int pageCount =
-                 matchCount > 0 && matchCount <= _pageSize
-                 ? 1
-                 : (int)Math.Ceiling((double)matchCount / _pageSize);
-
-            var results = facetResult.Facets
-                .First(x => x.Name == "_results")
-                .Output<TProjection>();
-
-            return (results, matchCount, pageCount);
-        }
+        return (results, matchCount, pageCount);
     }
 }
diff --git a/MongoDB.Entities/Builders/Replace.cs b/MongoDB.Entities/Builders/Replace.cs
index 1f02ea2d5..a47d203d0 100644
--- a/MongoDB.Entities/Builders/Replace.cs
+++ b/MongoDB.Entities/Builders/Replace.cs
@@ -1,136 +1,129 @@
-using MongoDB.Bson;
-using MongoDB.Bson.Serialization;
-using MongoDB.Driver;
-using System;
-using System.Collections.Generic;
-using System.Linq.Expressions;
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace MongoDB.Entities
+namespace MongoDB.Entities;
+
+/// <summary>
+/// Represents an UpdateOne command, which can replace the first matched document with a given entity
+/// <para>TIP: Specify a filter first with the .Match(). Then set entity with .WithEntity() and finally call .Execute() to run the command.</para>
+/// </summary>
+/// <typeparam name="T">Any class that implements IEntity</typeparam>
+/// <typeparam name="TId">ID type</typeparam>
+public class Replace<T, TId> : FilterQueryBase<T, TId, Replace<T, TId>>, ICollectionRelated<T>
+    where TId : IComparable<TId>, IEquatable<TId>
+    where T : IEntity<TId>
 {
+    private ReplaceOptions _options = new();
+    private readonly List<ReplaceOneModel<T>> _models = new();
+    private readonly ModifiedBy? _modifiedBy;
+    private readonly Action<T>? _onSaveAction;
+    private T? _entity;
+
+    public DBContext Context { get; }
+    public IMongoCollection<T> Collection { get; }
+
+    internal Replace(
+        DBContext context,
+        IMongoCollection<T> collection,
+        Action<T>? onSaveAction) : base(context.GlobalFilters)
+    {
+        Context = context;
+        Collection = collection;
+        _modifiedBy = context.ModifiedBy;
+        _onSaveAction = onSaveAction;
+    }
+
+
     /// <summary>
-    /// Represents an UpdateOne command, which can replace the first matched document with a given entity
-    /// <para>TIP: Specify a filter first with the .Match(). Then set entity with .WithEntity() and finally call .Execute() to run the command.</para>
+    /// Supply the entity to replace the first matched document with
+    /// <para>TIP: If the entity ID is empty, a new ID will be generated before being stored</para>
     /// </summary>
-    /// <typeparam name="T">Any class that implements IEntity</typeparam>
-    public class Replace<T> : FilterQueryBase<T, Replace<T>>, ICollectionRelated<T> where T : IEntity
+    /// <param name="entity"></param>
+    public Replace<T, TId> WithEntity(T entity)
     {
-        private ReplaceOptions _options = new();
-        private readonly List<ReplaceOneModel<T>> _models = new();
-        private readonly ModifiedBy? _modifiedBy;
-        private readonly Action<T>? _onSaveAction;
-        private T? _entity;
-
-        public DBContext Context { get; }
-        public IMongoCollection<T> Collection { get; }
-
-        internal Replace(
-            DBContext context,
-            IMongoCollection<T> collection,
-            Action<T>? onSaveAction) : base(context.GlobalFilters)
-        {
-            Context = context;
-            Collection = collection;
-            _modifiedBy = context.ModifiedBy;
-            _onSaveAction = onSaveAction;
-        }
+        if (entity.ID is null)
+            throw new InvalidOperationException("Cannot replace an entity with an empty ID value!");
 
+        _onSaveAction?.Invoke(entity);
 
-        /// <summary>
-        /// Supply the entity to replace the first matched document with
-        /// <para>TIP: If the entity ID is empty, a new ID will be generated before being stored</para>
-        /// </summary>
-        /// <param name="entity"></param>
-        public Replace<T> WithEntity(T entity)
-        {
-            if (string.IsNullOrEmpty(entity.ID))
-                throw new InvalidOperationException("Cannot replace an entity with an empty ID value!");
+        _entity = entity;
+        return this;
+    }
 
-            _onSaveAction?.Invoke(entity);
+    /// <summary>
+    /// Specify an option for this replace command (use multiple times if needed)
+    /// <para>TIP: Setting options is not required</para>
+    /// </summary>
+    /// <param name="option">x => x.OptionName = OptionValue</param>
+    public Replace<T, TId> Option(Action<ReplaceOptions> option)
+    {
+        option(_options);
+        return this;
+    }
 
-            _entity = entity;
-            return this;
-        }
 
-        /// <summary>
-        /// Specify an option for this replace command (use multiple times if needed)
-        /// <para>TIP: Setting options is not required</para>
-        /// </summary>
-        /// <param name="option">x => x.OptionName = OptionValue</param>
-        public Replace<T> Option(Action<ReplaceOptions> option)
+    /// <summary>
+    /// Queue up a replace command for bulk execution later.
+    /// </summary>
+    public Replace<T, TId> AddToQueue()
+    {
+        var mergedFilter = Logic.MergeWithGlobalFilter(_ignoreGlobalFilters, _globalFilters, _filter);
+        if (mergedFilter == Builders<T>.Filter.Empty) throw new ArgumentException("Please use Match() method first!");
+        if (_entity == null) throw new ArgumentException("Please use WithEntity() method first!");
+        SetModOnAndByValues();
+
+        _models.Add(new ReplaceOneModel<T>(mergedFilter, _entity)
         {
-            option(_options);
-            return this;
-        }
+            Collation = _options.Collation,
+            Hint = _options.Hint,
+            IsUpsert = _options.IsUpsert
+        });
+        _filter = Builders<T>.Filter.Empty;
+        _entity = default;
+        _options = new ReplaceOptions();
+        return this;
+    }
+
+    /// <summary>
+    /// Run the replace command in MongoDB.
+    /// </summary>
+    /// <param name="cancellation">An optional cancellation token</param>
+    public async Task<ReplaceOneResult> ExecuteAsync(CancellationToken cancellation = default)
+    {
+        if (_models.Count > 0)
+        {
+            var bulkWriteResult = await (
+                this.Session() is not IClientSessionHandle session
+                ? Collection.BulkWriteAsync(_models, null, cancellation)
+                : Collection.BulkWriteAsync(session, _models, null, cancellation)
+                ).ConfigureAwait(false);
 
+            _models.Clear();
 
-        /// <summary>
-        /// Queue up a replace command for bulk execution later.
-        /// </summary>
-        public Replace<T> AddToQueue()
+            if (!bulkWriteResult.IsAcknowledged)
+                return ReplaceOneResult.Unacknowledged.Instance;
+
+            return new ReplaceOneResult.Acknowledged(bulkWriteResult.MatchedCount, bulkWriteResult.ModifiedCount, null);
+        }
+        else
         {
-            var mergedFilter = Logic.MergeWithGlobalFilter(_ignoreGlobalFilters, _globalFilters, _filter);
+            var mergedFilter = MergedFilter;
             if (mergedFilter == Builders<T>.Filter.Empty) throw new ArgumentException("Please use Match() method first!");
             if (_entity == null) throw new ArgumentException("Please use WithEntity() method first!");
             SetModOnAndByValues();
 
-            _models.Add(new ReplaceOneModel<T>(mergedFilter, _entity)
-            {
-                Collation = _options.Collation,
-                Hint = _options.Hint,
-                IsUpsert = _options.IsUpsert
-            });
-            _filter = Builders<T>.Filter.Empty;
-            _entity = default;
-            _options = new ReplaceOptions();
-            return this;
-        }
-
-        /// <summary>
-        /// Run the replace command in MongoDB.
-        /// </summary>
-        /// <param name="cancellation">An optional cancellation token</param>
-        public async Task<ReplaceOneResult> ExecuteAsync(CancellationToken cancellation = default)
-        {
-            if (_models.Count > 0)
-            {
-                var bulkWriteResult = await (
-                    this.Session() is not IClientSessionHandle session
-                    ? Collection.BulkWriteAsync(_models, null, cancellation)
-                    : Collection.BulkWriteAsync(session, _models, null, cancellation)
-                    ).ConfigureAwait(false);
-
-                _models.Clear();
-
-                if (!bulkWriteResult.IsAcknowledged)
-                    return ReplaceOneResult.Unacknowledged.Instance;
-
-                return new ReplaceOneResult.Acknowledged(bulkWriteResult.MatchedCount, bulkWriteResult.ModifiedCount, null);
-            }
-            else
-            {
-                var mergedFilter = MergedFilter;
-                if (mergedFilter == Builders<T>.Filter.Empty) throw new ArgumentException("Please use Match() method first!");
-                if (_entity == null) throw new ArgumentException("Please use WithEntity() method first!");
-                SetModOnAndByValues();
-
-                return this.Session() is not IClientSessionHandle session
-                       ? await Collection.ReplaceOneAsync(mergedFilter, _entity, _options, cancellation).ConfigureAwait(false)
-                       : await Collection.ReplaceOneAsync(session, mergedFilter, _entity, _options, cancellation).ConfigureAwait(false);
-            }
+            return this.Session() is not IClientSessionHandle session
+                   ? await Collection.ReplaceOneAsync(mergedFilter, _entity, _options, cancellation).ConfigureAwait(false)
+                   : await Collection.ReplaceOneAsync(session, mergedFilter, _entity, _options, cancellation).ConfigureAwait(false);
         }
+    }
 
-        private void SetModOnAndByValues()
+    private void SetModOnAndByValues()
+    {
+        var cache = Context.Cache<T>();
+        if (cache.HasModifiedOn && _entity is IModifiedOn _entityModifiedOn) _entityModifiedOn.ModifiedOn = DateTime.UtcNow;
+        if (cache.ModifiedByProp != null && _modifiedBy != null)
         {
-            var cache = Context.Cache<T>();
-            if (cache.HasModifiedOn && _entity is IModifiedOn _entityModifiedOn) _entityModifiedOn.ModifiedOn = DateTime.UtcNow;
-            if (cache.ModifiedByProp != null && _modifiedBy != null)
-            {
-                cache.ModifiedByProp.SetValue(
-                    _entity,
-                    BsonSerializer.Deserialize(_modifiedBy.ToBson(), cache.ModifiedByProp.PropertyType));
-            }
+            cache.ModifiedByProp.SetValue(
+                _entity,
+                BsonSerializer.Deserialize(_modifiedBy.ToBson(), cache.ModifiedByProp.PropertyType));
         }
     }
 }
diff --git a/MongoDB.Entities/Builders/SortFilterQueryBase.cs b/MongoDB.Entities/Builders/SortFilterQueryBase.cs
index 08eb7d9ab..0a1e97d64 100644
--- a/MongoDB.Entities/Builders/SortFilterQueryBase.cs
+++ b/MongoDB.Entities/Builders/SortFilterQueryBase.cs
@@ -1,48 +1,45 @@
-using MongoDB.Driver;
-using System;
-using System.Collections.Generic;
-using System.Linq.Expressions;
-#nullable enable
-namespace MongoDB.Entities
+namespace MongoDB.Entities;
+
+public abstract class SortFilterQueryBase<T, TId, TSelf> : FilterQueryBase<T, TId, TSelf>
+    where TId : IComparable<TId>, IEquatable<TId>
+    where T : IEntity<TId>
+    where TSelf : SortFilterQueryBase<T, TId, TSelf>
 {
-    public abstract class SortFilterQueryBase<T, TSelf> : FilterQueryBase<T, TSelf> where T : IEntity where TSelf : SortFilterQueryBase<T, TSelf>
-    {
-        internal List<SortDefinition<T>> _sorts = new();
-        private TSelf This => (TSelf)this;
+    internal List<SortDefinition<T>> _sorts = new();
+    private TSelf This => (TSelf)this;
 
-        internal SortFilterQueryBase(SortFilterQueryBase<T, TSelf> other) : base(other)
-        {
-            _sorts = other._sorts;
-        }
-        internal SortFilterQueryBase(Dictionary<Type, (object filterDef, bool prepend)> globalFilters) : base(globalFilters: globalFilters)
-        {
-        }
+    internal SortFilterQueryBase(SortFilterQueryBase<T, TId, TSelf> other) : base(other)
+    {
+        _sorts = other._sorts;
+    }
+    internal SortFilterQueryBase(Dictionary<Type, (object filterDef, bool prepend)> globalFilters) : base(globalFilters: globalFilters)
+    {
+    }
 
 
-        /// <summary>
-        /// Specify which property and order to use for sorting (use multiple times if needed)
-        /// </summary>
-        /// <param name="propertyToSortBy">x => x.Prop</param>
-        /// <param name="sortOrder">The sort order</param>
-        public TSelf Sort(Expression<Func<T, object>> propertyToSortBy, Order sortOrder)
+    /// <summary>
+    /// Specify which property and order to use for sorting (use multiple times if needed)
+    /// </summary>
+    /// <param name="propertyToSortBy">x => x.Prop</param>
+    /// <param name="sortOrder">The sort order</param>
+    public TSelf Sort(Expression<Func<T, object>> propertyToSortBy, Order sortOrder)
+    {
+        return sortOrder switch
         {
-            return sortOrder switch
-            {
-                Order.Ascending => Sort(s => s.Ascending(propertyToSortBy)),
-                Order.Descending => Sort(s => s.Descending(propertyToSortBy)),
-                _ => This,
-            };
-        }
+            Order.Ascending => Sort(s => s.Ascending(propertyToSortBy)),
+            Order.Descending => Sort(s => s.Descending(propertyToSortBy)),
+            _ => This,
+        };
+    }
 
-        /// <summary>
-        /// Specify how to sort using a sort expression
-        /// </summary>
-        /// <param name="sortFunction">s => s.Ascending("Prop1").MetaTextScore("Prop2")</param>
-        /// <returns></returns>
-        public TSelf Sort(Func<SortDefinitionBuilder<T>, SortDefinition<T>> sortFunction)
-        {
-            _sorts.Add(sortFunction(Builders<T>.Sort));
-            return This;
-        }
+    /// <summary>
+    /// Specify how to sort using a sort expression
+    /// </summary>
+    /// <param name="sortFunction">s => s.Ascending("Prop1").MetaTextScore("Prop2")</param>
+    /// <returns></returns>
+    public TSelf Sort(Func<SortDefinitionBuilder<T>, SortDefinition<T>> sortFunction)
+    {
+        _sorts.Add(sortFunction(Builders<T>.Sort));
+        return This;
     }
 }
diff --git a/MongoDB.Entities/Builders/Update.cs b/MongoDB.Entities/Builders/Update.cs
index 0f9426fbb..e9fb8891e 100644
--- a/MongoDB.Entities/Builders/Update.cs
+++ b/MongoDB.Entities/Builders/Update.cs
@@ -1,364 +1,360 @@
-using MongoDB.Bson.Serialization;
-using MongoDB.Driver;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Linq.Expressions;
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace MongoDB.Entities
-{
-    public abstract class UpdateBase<T, TSelf> : FilterQueryBase<T, TSelf> where T : IEntity where TSelf : UpdateBase<T, TSelf>
-    {
-        protected readonly List<UpdateDefinition<T>> defs;
-        protected readonly Action<TSelf>? onUpdateAction;
-
-        public abstract DBContext Context { get; }
-        private EntityCache<T>? _cache;
-        internal EntityCache<T> Cache() => _cache ??= Context.Cache<T>();
+namespace MongoDB.Entities;
 
-        internal UpdateBase(UpdateBase<T, TSelf> other) : base(other)
-        {
-            onUpdateAction = other.onUpdateAction;
-            defs = other.defs;
-        }
-        private TSelf This => (TSelf)this;
-        internal UpdateBase(Dictionary<Type, (object filterDef, bool prepend)> globalFilters, Action<TSelf>? onUpdateAction = null, List<UpdateDefinition<T>>? defs = null) : base(globalFilters)
-        {
-            this.onUpdateAction = onUpdateAction;
-            this.defs = defs ?? new();
-        }
+public abstract class UpdateBase<T, TId, TSelf> : FilterQueryBase<T, TId, TSelf>
+    where TId : IComparable<TId>, IEquatable<TId>
+    where T : IEntity<TId>
+    where TSelf : UpdateBase<T, TId, TSelf>
+{
+    protected readonly List<UpdateDefinition<T>> defs;
+    protected readonly Action<TSelf>? onUpdateAction;
 
-        /// <summary>
-        /// Specify the property and it's value to modify (use multiple times if needed)
-        /// </summary>
-        /// <param name="property">x => x.Property</param>
-        /// <param name="value">The value to set on the property</param>
-        public void AddModification<TProp>(Expression<Func<T, TProp>> property, TProp value)
-        {
-            defs.Add(Builders<T>.Update.Set(property, value));
-        }
+    public abstract DBContext Context { get; }
+    private EntityCache<T>? _cache;
+    internal EntityCache<T> Cache() => _cache ??= Context.Cache<T>();
 
-        /// <summary>
-        /// Specify the update definition builder operation to modify the Entities (use multiple times if needed)
-        /// </summary>
-        /// <param name="operation">b => b.Inc(x => x.PropName, Value)</param>
-        public void AddModification(Func<UpdateDefinitionBuilder<T>, UpdateDefinition<T>> operation)
-        {
-            defs.Add(operation(Builders<T>.Update));
-        }
+    internal UpdateBase(UpdateBase<T, TId, TSelf> other) : base(other)
+    {
+        onUpdateAction = other.onUpdateAction;
+        defs = other.defs;
+    }
+    private TSelf This => (TSelf)this;
+    internal UpdateBase(Dictionary<Type, (object filterDef, bool prepend)> globalFilters, Action<TSelf>? onUpdateAction = null, List<UpdateDefinition<T>>? defs = null) : base(globalFilters)
+    {
+        this.onUpdateAction = onUpdateAction;
+        this.defs = defs ?? new();
+    }
 
-        /// <summary>
-        /// Specify an update (json string) to modify the Entities (use multiple times if needed)
-        /// </summary>
-        /// <param name="update">{ $set: { 'RootProp.$[x].SubProp' : 321 } }</param>
-        public void AddModification(string update)
-        {
-            defs.Add(update);
-        }
+    /// <summary>
+    /// Specify the property and it's value to modify (use multiple times if needed)
+    /// </summary>
+    /// <param name="property">x => x.Property</param>
+    /// <param name="value">The value to set on the property</param>
+    public void AddModification<TProp>(Expression<Func<T, TProp>> property, TProp value)
+    {
+        defs.Add(Builders<T>.Update.Set(property, value));
+    }
 
-        /// <summary>
-        /// Specify an update with a Template to modify the Entities (use multiple times if needed)
-        /// </summary>
-        /// <param name="template">A Template with a single update</param>
-        public void AddModification(Template template)
-        {
-            AddModification(template.RenderToString());
-        }
+    /// <summary>
+    /// Specify the update definition builder operation to modify the Entities (use multiple times if needed)
+    /// </summary>
+    /// <param name="operation">b => b.Inc(x => x.PropName, Value)</param>
+    public void AddModification(Func<UpdateDefinitionBuilder<T>, UpdateDefinition<T>> operation)
+    {
+        defs.Add(operation(Builders<T>.Update));
+    }
 
+    /// <summary>
+    /// Specify an update (json string) to modify the Entities (use multiple times if needed)
+    /// </summary>
+    /// <param name="update">{ $set: { 'RootProp.$[x].SubProp' : 321 } }</param>
+    public void AddModification(string update)
+    {
+        defs.Add(update);
+    }
 
-        /// <summary>
-        /// Specify the property and it's value to modify (use multiple times if needed)
-        /// </summary>
-        /// <param name="property">x => x.Property</param>
-        /// <param name="value">The value to set on the property</param>
-        public TSelf Modify<TProp>(Expression<Func<T, TProp>> property, TProp value)
-        {
-            AddModification(property, value);
-            return This;
-        }
+    /// <summary>
+    /// Specify an update with a Template to modify the Entities (use multiple times if needed)
+    /// </summary>
+    /// <param name="template">A Template with a single update</param>
+    public void AddModification(Template template)
+    {
+        AddModification(template.RenderToString());
+    }
 
-        /// <summary>
-        /// Specify the update definition builder operation to modify the Entities (use multiple times if needed)
-        /// </summary>
-        /// <param name="operation">b => b.Inc(x => x.PropName, Value)</param>
-        /// <returns></returns>
-        public TSelf Modify(Func<UpdateDefinitionBuilder<T>, UpdateDefinition<T>> operation)
-        {
-            AddModification(operation);
-            return This;
-        }
 
-        /// <summary>
-        /// Specify an update (json string) to modify the Entities (use multiple times if needed)
-        /// </summary>
-        /// <param name="update">{ $set: { 'RootProp.$[x].SubProp' : 321 } }</param>
-        public TSelf Modify(string update)
-        {
-            AddModification(update);
-            return This;
-        }
+    /// <summary>
+    /// Specify the property and it's value to modify (use multiple times if needed)
+    /// </summary>
+    /// <param name="property">x => x.Property</param>
+    /// <param name="value">The value to set on the property</param>
+    public TSelf Modify<TProp>(Expression<Func<T, TProp>> property, TProp value)
+    {
+        AddModification(property, value);
+        return This;
+    }
 
-        /// <summary>
-        /// Specify an update with a Template to modify the Entities (use multiple times if needed)
-        /// </summary>
-        /// <param name="template">A Template with a single update</param>
-        public TSelf Modify(Template template)
-        {
-            AddModification(template.RenderToString());
-            return This;
-        }
+    /// <summary>
+    /// Specify the update definition builder operation to modify the Entities (use multiple times if needed)
+    /// </summary>
+    /// <param name="operation">b => b.Inc(x => x.PropName, Value)</param>
+    /// <returns></returns>
+    public TSelf Modify(Func<UpdateDefinitionBuilder<T>, UpdateDefinition<T>> operation)
+    {
+        AddModification(operation);
+        return This;
+    }
 
-        /// <summary>
-        /// Modify ALL properties with the values from the supplied entity instance.
-        /// </summary>
-        /// <param name="entity">The entity instance to read the property values from</param>
-        public TSelf ModifyWith(T entity)
-        {
+    /// <summary>
+    /// Specify an update (json string) to modify the Entities (use multiple times if needed)
+    /// </summary>
+    /// <param name="update">{ $set: { 'RootProp.$[x].SubProp' : 321 } }</param>
+    public TSelf Modify(string update)
+    {
+        AddModification(update);
+        return This;
+    }
 
-            if (Cache().HasModifiedOn) ((IModifiedOn)entity).ModifiedOn = DateTime.UtcNow;
-            defs.AddRange(Logic.BuildUpdateDefs(entity, Context));
-            return This;
-        }
+    /// <summary>
+    /// Specify an update with a Template to modify the Entities (use multiple times if needed)
+    /// </summary>
+    /// <param name="template">A Template with a single update</param>
+    public TSelf Modify(Template template)
+    {
+        AddModification(template.RenderToString());
+        return This;
+    }
 
-        /// <summary>
-        /// Modify ONLY the specified properties with the values from a given entity instance.
-        /// </summary>
-        /// <param name="members">A new expression with the properties to include. Ex: <c>x => new { x.PropOne, x.PropTwo }</c></param>
-        /// <param name="entity">The entity instance to read the corresponding values from</param>
-        public TSelf ModifyOnly(Expression<Func<T, object>> members, T entity)
-        {
-            if (Cache().HasModifiedOn) ((IModifiedOn)entity).ModifiedOn = DateTime.UtcNow;
-            defs.AddRange(Logic.BuildUpdateDefs(entity, members));
-            return This;
-        }
+    /// <summary>
+    /// Modify ALL properties with the values from the supplied entity instance.
+    /// </summary>
+    /// <param name="entity">The entity instance to read the property values from</param>
+    public TSelf ModifyWith(T entity)
+    {
 
-        /// <summary>
-        /// Modify all EXCEPT the specified properties with the values from a given entity instance.
-        /// </summary>
-        /// <param name="members">Supply a new expression with the properties to exclude. Ex: <c>x => new { x.Prop1, x.Prop2 }</c></param>
-        /// <param name="entity">The entity instance to read the corresponding values from</param>
-        public TSelf ModifyExcept(Expression<Func<T, object>> members, T entity)
-        {
-            if (Cache().HasModifiedOn) ((IModifiedOn)entity).ModifiedOn = DateTime.UtcNow;
-            defs.AddRange(Logic.BuildUpdateDefs(entity, members, excludeMode: true));
-            return This;
-        }
+        if (Cache().HasModifiedOn) ((IModifiedOn)entity).ModifiedOn = DateTime.UtcNow;
+        defs.AddRange(Logic.BuildUpdateDefs(entity, Context));
+        return This;
     }
 
     /// <summary>
-    /// Represents an update command
-    /// <para>TIP: Specify a filter first with the .Match(). Then set property values with .Modify() and finally call .Execute() to run the command.</para>
+    /// Modify ONLY the specified properties with the values from a given entity instance.
     /// </summary>
-    /// <typeparam name="T">Any class that implements IEntity</typeparam>
-    public class Update<T> : UpdateBase<T, Update<T>>, ICollectionRelated<T> where T : IEntity
+    /// <param name="members">A new expression with the properties to include. Ex: <c>x => new { x.PropOne, x.PropTwo }</c></param>
+    /// <param name="entity">The entity instance to read the corresponding values from</param>
+    public TSelf ModifyOnly(Expression<Func<T, object>> members, T entity)
     {
-        private readonly List<PipelineStageDefinition<T, T>> _stages = new();
-        private UpdateOptions _options = new();
-        private readonly List<UpdateManyModel<T>> _models = new();
+        if (Cache().HasModifiedOn) ((IModifiedOn)entity).ModifiedOn = DateTime.UtcNow;
+        defs.AddRange(Logic.BuildUpdateDefs(entity, members, Context));
+        return This;
+    }
 
-        internal Update(DBContext context, IMongoCollection<T> collection, UpdateBase<T, Update<T>> other) : base(other)
-        {
-            Context = context;
-            Collection = collection;
-        }
+    /// <summary>
+    /// Modify all EXCEPT the specified properties with the values from a given entity instance.
+    /// </summary>
+    /// <param name="members">Supply a new expression with the properties to exclude. Ex: <c>x => new { x.Prop1, x.Prop2 }</c></param>
+    /// <param name="entity">The entity instance to read the corresponding values from</param>
+    public TSelf ModifyExcept(Expression<Func<T, object>> members, T entity)
+    {
+        if (Cache().HasModifiedOn) ((IModifiedOn)entity).ModifiedOn = DateTime.UtcNow;
+        defs.AddRange(Logic.BuildUpdateDefs(entity, members, Context, excludeMode: true));
+        return This;
+    }
+}
 
-        internal Update(DBContext context, IMongoCollection<T> collection, Action<Update<T>>? onUpdateAction, List<UpdateDefinition<T>>? defs = null) : base(context.GlobalFilters, onUpdateAction, defs)
-        {
-            Context = context;
-            Collection = collection;
-        }
+/// <summary>
+/// Represents an update command
+/// <para>TIP: Specify a filter first with the .Match(). Then set property values with .Modify() and finally call .Execute() to run the command.</para>
+/// </summary>
+/// <typeparam name="T">Any class that implements IEntity</typeparam>
+/// <typeparam name="TId">ID type</typeparam>
+public class Update<T, TId> : UpdateBase<T, TId, Update<T, TId>>, ICollectionRelated<T>
+    where TId : IComparable<TId>, IEquatable<TId>
+    where T : IEntity<TId>
+{
+    private readonly List<PipelineStageDefinition<T, T>> _stages = new();
+    private UpdateOptions _options = new();
+    private readonly List<UpdateManyModel<T>> _models = new();
 
-        public override DBContext Context { get; }
-        public IMongoCollection<T> Collection { get; }
+    internal Update(DBContext context, IMongoCollection<T> collection, UpdateBase<T, TId, Update<T, TId>> other) : base(other)
+    {
+        Context = context;
+        Collection = collection;
+    }
 
+    internal Update(DBContext context, IMongoCollection<T> collection, Action<Update<T, TId>>? onUpdateAction, List<UpdateDefinition<T>>? defs = null) : base(context.GlobalFilters, onUpdateAction, defs)
+    {
+        Context = context;
+        Collection = collection;
+    }
 
-        /// <summary>
-        /// Specify an update pipeline with multiple stages using a Template to modify the Entities.
-        /// <para>NOTE: pipeline updates and regular updates cannot be used together.</para>
-        /// </summary>
-        /// <param name="template">A Template object containing multiple pipeline stages</param>
-        public Update<T> WithPipeline(Template template)
-        {
-            foreach (var stage in template.ToStages())
-            {
-                _stages.Add(stage);
-            }
+    public override DBContext Context { get; }
+    public IMongoCollection<T> Collection { get; }
 
-            return this;
-        }
 
-        /// <summary>
-        /// Specify an update pipeline stage to modify the Entities (use multiple times if needed)
-        /// <para>NOTE: pipeline updates and regular updates cannot be used together.</para>
-        /// </summary>
-        /// <param name="stage">{ $set: { FullName: { $concat: ['$Name', ' ', '$Surname'] } } }</param>
-        public Update<T> WithPipelineStage(string stage)
+    /// <summary>
+    /// Specify an update pipeline with multiple stages using a Template to modify the Entities.
+    /// <para>NOTE: pipeline updates and regular updates cannot be used together.</para>
+    /// </summary>
+    /// <param name="template">A Template object containing multiple pipeline stages</param>
+    public Update<T, TId> WithPipeline(Template template)
+    {
+        foreach (var stage in template.ToStages())
         {
             _stages.Add(stage);
-            return this;
         }
 
-        /// <summary>
-        /// Specify an update pipeline stage using a Template to modify the Entities (use multiple times if needed)
-        /// <para>NOTE: pipeline updates and regular updates cannot be used together.</para>
-        /// </summary>
-        /// <param name="template">A Template object containing a pipeline stage</param>
-        public Update<T> WithPipelineStage(Template template)
-        {
-            return WithPipelineStage(template.RenderToString());
-        }
+        return this;
+    }
 
-        /// <summary>
-        /// Specify an array filter to target nested entities for updates (use multiple times if needed).
-        /// </summary>
-        /// <param name="filter">{ 'x.SubProp': { $gte: 123 } }</param>
-        public Update<T> WithArrayFilter(string filter)
-        {
-            ArrayFilterDefinition<T> def = filter;
+    /// <summary>
+    /// Specify an update pipeline stage to modify the Entities (use multiple times if needed)
+    /// <para>NOTE: pipeline updates and regular updates cannot be used together.</para>
+    /// </summary>
+    /// <param name="stage">{ $set: { FullName: { $concat: ['$Name', ' ', '$Surname'] } } }</param>
+    public Update<T, TId> WithPipelineStage(string stage)
+    {
+        _stages.Add(stage);
+        return this;
+    }
 
-            _options.ArrayFilters =
-                _options.ArrayFilters == null
-                ? new[] { def }
-                : _options.ArrayFilters.Concat(new[] { def });
+    /// <summary>
+    /// Specify an update pipeline stage using a Template to modify the Entities (use multiple times if needed)
+    /// <para>NOTE: pipeline updates and regular updates cannot be used together.</para>
+    /// </summary>
+    /// <param name="template">A Template object containing a pipeline stage</param>
+    public Update<T, TId> WithPipelineStage(Template template)
+    {
+        return WithPipelineStage(template.RenderToString());
+    }
 
-            return this;
-        }
+    /// <summary>
+    /// Specify an array filter to target nested entities for updates (use multiple times if needed).
+    /// </summary>
+    /// <param name="filter">{ 'x.SubProp': { $gte: 123 } }</param>
+    public Update<T, TId> WithArrayFilter(string filter)
+    {
+        ArrayFilterDefinition<T> def = filter;
 
-        /// <summary>
-        /// Specify a single array filter using a Template to target nested entities for updates
-        /// </summary>
-        /// <param name="template"></param>
-        public Update<T> WithArrayFilter(Template template)
-        {
-            WithArrayFilter(template.RenderToString());
-            return this;
-        }
+        _options.ArrayFilters =
+            _options.ArrayFilters == null
+            ? new[] { def }
+            : _options.ArrayFilters.Concat(new[] { def });
 
-        /// <summary>
-        /// Specify multiple array filters with a Template to target nested entities for updates.
-        /// </summary>
-        /// <param name="template">The template with an array [...] of filters</param>
-        public Update<T> WithArrayFilters(Template template)
-        {
-            var defs = template.ToArrayFilters<T>();
+        return this;
+    }
 
-            _options.ArrayFilters =
-                _options.ArrayFilters == null
-                ? defs
-                : _options.ArrayFilters.Concat(defs);
+    /// <summary>
+    /// Specify a single array filter using a Template to target nested entities for updates
+    /// </summary>
+    /// <param name="template"></param>
+    public Update<T, TId> WithArrayFilter(Template template)
+    {
+        WithArrayFilter(template.RenderToString());
+        return this;
+    }
 
-            return this;
-        }
+    /// <summary>
+    /// Specify multiple array filters with a Template to target nested entities for updates.
+    /// </summary>
+    /// <param name="template">The template with an array [...] of filters</param>
+    public Update<T, TId> WithArrayFilters(Template template)
+    {
+        var defs = template.ToArrayFilters<T>();
 
-        /// <summary>
-        /// Specify an option for this update command (use multiple times if needed)
-        /// <para>TIP: Setting options is not required</para>
-        /// </summary>
-        /// <param name="option">x => x.OptionName = OptionValue</param>
-        public Update<T> Option(Action<UpdateOptions> option)
-        {
-            option(_options);
-            return this;
-        }
+        _options.ArrayFilters =
+            _options.ArrayFilters == null
+            ? defs
+            : _options.ArrayFilters.Concat(defs);
+
+        return this;
+    }
+
+    /// <summary>
+    /// Specify an option for this update command (use multiple times if needed)
+    /// <para>TIP: Setting options is not required</para>
+    /// </summary>
+    /// <param name="option">x => x.OptionName = OptionValue</param>
+    public Update<T, TId> Option(Action<UpdateOptions> option)
+    {
+        option(_options);
+        return this;
+    }
 
 
 
-        /// <summary>
-        /// Queue up an update command for bulk execution later.
-        /// </summary>
-        public Update<T> AddToQueue()
+    /// <summary>
+    /// Queue up an update command for bulk execution later.
+    /// </summary>
+    public Update<T, TId> AddToQueue()
+    {
+        var mergedFilter = MergedFilter;
+        if (mergedFilter == Builders<T>.Filter.Empty) throw new ArgumentException("Please use Match() method first!");
+        if (defs.Count == 0) throw new ArgumentException("Please use Modify() method first!");
+        if (Cache().HasModifiedOn) Modify(b => b.CurrentDate(Cache().ModifiedOnPropName));
+        onUpdateAction?.Invoke(this);
+        _models.Add(new UpdateManyModel<T>(mergedFilter, Builders<T>.Update.Combine(defs))
         {
-            var mergedFilter = MergedFilter;
-            if (mergedFilter == Builders<T>.Filter.Empty) throw new ArgumentException("Please use Match() method first!");
-            if (defs.Count == 0) throw new ArgumentException("Please use Modify() method first!");
-            if (Cache().HasModifiedOn) Modify(b => b.CurrentDate(Cache().ModifiedOnPropName));
-            onUpdateAction?.Invoke(this);
-            _models.Add(new UpdateManyModel<T>(mergedFilter, Builders<T>.Update.Combine(defs))
-            {
-                ArrayFilters = _options.ArrayFilters,
-                Collation = _options.Collation,
-                Hint = _options.Hint,
-                IsUpsert = _options.IsUpsert
-            });
-            _filter = Builders<T>.Filter.Empty;
-            defs.Clear();
-            _options = new UpdateOptions();
-            return this;
-        }
+            ArrayFilters = _options.ArrayFilters,
+            Collation = _options.Collation,
+            Hint = _options.Hint,
+            IsUpsert = _options.IsUpsert
+        });
+        _filter = Builders<T>.Filter.Empty;
+        defs.Clear();
+        _options = new UpdateOptions();
+        return this;
+    }
 
-        /// <summary>
-        /// Run the update command in MongoDB.
-        /// </summary>
-        /// <param name="cancellation">An optional cancellation token</param>
-        public async Task<UpdateResult> ExecuteAsync(CancellationToken cancellation = default)
+    /// <summary>
+    /// Run the update command in MongoDB.
+    /// </summary>
+    /// <param name="cancellation">An optional cancellation token</param>
+    public async Task<UpdateResult> ExecuteAsync(CancellationToken cancellation = default)
+    {
+        if (_models.Count > 0)
         {
-            if (_models.Count > 0)
-            {
-                var bulkWriteResult = await (
-                    this.Session() is not IClientSessionHandle session
-                    ? Collection.BulkWriteAsync(_models, null, cancellation)
-                    : Collection.BulkWriteAsync(session, _models, null, cancellation)
-                    ).ConfigureAwait(false);
-
-                _models.Clear();
-
-                if (!bulkWriteResult.IsAcknowledged)
-                    return UpdateResult.Unacknowledged.Instance;
-
-                return new UpdateResult.Acknowledged(bulkWriteResult.MatchedCount, bulkWriteResult.ModifiedCount, null);
-            }
-            else
-            {
-                var mergedFilter = MergedFilter;
-                if (mergedFilter == Builders<T>.Filter.Empty) throw new ArgumentException("Please use Match() method first!");
-                if (defs.Count == 0) throw new ArgumentException("Please use a Modify() method first!");
-                if (_stages.Count > 0) throw new ArgumentException("Regular updates and Pipeline updates cannot be used together!");
-                if (ShouldSetModDate()) Modify(b => b.CurrentDate(Cache().ModifiedOnPropName));
-
-                onUpdateAction?.Invoke(this);
-                return await UpdateAsync(mergedFilter, Builders<T>.Update.Combine(defs), _options, cancellation).ConfigureAwait(false);
-            }
-        }
+            var bulkWriteResult = await (
+                this.Session() is not IClientSessionHandle session
+                ? Collection.BulkWriteAsync(_models, null, cancellation)
+                : Collection.BulkWriteAsync(session, _models, null, cancellation)
+                ).ConfigureAwait(false);
+
+            _models.Clear();
+
+            if (!bulkWriteResult.IsAcknowledged)
+                return UpdateResult.Unacknowledged.Instance;
 
-        /// <summary>
-        /// Run the update command with pipeline stages
-        /// </summary>
-        /// <param name="cancellation">An optional cancellation token</param>
-        public Task<UpdateResult> ExecutePipelineAsync(CancellationToken cancellation = default)
+            return new UpdateResult.Acknowledged(bulkWriteResult.MatchedCount, bulkWriteResult.ModifiedCount, null);
+        }
+        else
         {
             var mergedFilter = MergedFilter;
             if (mergedFilter == Builders<T>.Filter.Empty) throw new ArgumentException("Please use Match() method first!");
-            if (_stages.Count == 0) throw new ArgumentException("Please use WithPipelineStage() method first!");
-            if (defs.Count > 0) throw new ArgumentException("Pipeline updates cannot be used together with regular updates!");
-            if (ShouldSetModDate()) WithPipelineStage($"{{ $set: {{ '{Cache().ModifiedOnPropName}': new Date() }} }}");
-
-            return UpdateAsync(
-                mergedFilter,
-                Builders<T>.Update.Pipeline(_stages.ToArray()),
-                _options,
-                cancellation);
-        }
+            if (defs.Count == 0) throw new ArgumentException("Please use a Modify() method first!");
+            if (_stages.Count > 0) throw new ArgumentException("Regular updates and Pipeline updates cannot be used together!");
+            if (ShouldSetModDate()) Modify(b => b.CurrentDate(Cache().ModifiedOnPropName));
 
-        private bool ShouldSetModDate()
-        {
-            //only set mod date by library if user hasn't done anything with the ModifiedOn property
-
-            return
-                Cache().HasModifiedOn &&
-                !defs.Any(d => d
-                       .Render(BsonSerializer.SerializerRegistry.GetSerializer<T>(), BsonSerializer.SerializerRegistry)
-                       .ToString()
-                       .Contains($"\"{Cache().ModifiedOnPropName}\""));
+            onUpdateAction?.Invoke(this);
+            return await UpdateAsync(mergedFilter, Builders<T>.Update.Combine(defs), _options, cancellation).ConfigureAwait(false);
         }
+    }
 
-        private Task<UpdateResult> UpdateAsync(FilterDefinition<T> filter, UpdateDefinition<T> definition, UpdateOptions options, CancellationToken cancellation = default)
-        {
-            return Context.Session is null
-                   ? Collection.UpdateManyAsync(filter, definition, options, cancellation)
-                   : Collection.UpdateManyAsync(Context.Session, filter, definition, options, cancellation);
-        }
+    /// <summary>
+    /// Run the update command with pipeline stages
+    /// </summary>
+    /// <param name="cancellation">An optional cancellation token</param>
+    public Task<UpdateResult> ExecutePipelineAsync(CancellationToken cancellation = default)
+    {
+        var mergedFilter = MergedFilter;
+        if (mergedFilter == Builders<T>.Filter.Empty) throw new ArgumentException("Please use Match() method first!");
+        if (_stages.Count == 0) throw new ArgumentException("Please use WithPipelineStage() method first!");
+        if (defs.Count > 0) throw new ArgumentException("Pipeline updates cannot be used together with regular updates!");
+        if (ShouldSetModDate()) WithPipelineStage($"{{ $set: {{ '{Cache().ModifiedOnPropName}': new Date() }} }}");
+
+        return UpdateAsync(
+            mergedFilter,
+            Builders<T>.Update.Pipeline(_stages.ToArray()),
+            _options,
+            cancellation);
+    }
 
+    private bool ShouldSetModDate()
+    {
+        //only set mod date by library if user hasn't done anything with the ModifiedOn property
+
+        return
+            Cache().HasModifiedOn &&
+            !defs.Any(d => d
+                   .Render(BsonSerializer.SerializerRegistry.GetSerializer<T>(), BsonSerializer.SerializerRegistry)
+                   .ToString()
+                   .Contains($"\"{Cache().ModifiedOnPropName}\""));
     }
+
+    private Task<UpdateResult> UpdateAsync(FilterDefinition<T> filter, UpdateDefinition<T> definition, UpdateOptions options, CancellationToken cancellation = default)
+    {
+        return Context.Session is null
+               ? Collection.UpdateManyAsync(filter, definition, options, cancellation)
+               : Collection.UpdateManyAsync(Context.Session, filter, definition, options, cancellation);
+    }
+
 }
diff --git a/MongoDB.Entities/Builders/UpdateAndGet.cs b/MongoDB.Entities/Builders/UpdateAndGet.cs
index 63ce7e30a..6bea924c3 100644
--- a/MongoDB.Entities/Builders/UpdateAndGet.cs
+++ b/MongoDB.Entities/Builders/UpdateAndGet.cs
@@ -14,13 +14,16 @@ namespace MongoDB.Entities
     /// <para>TIP: Specify a filter first with the .Match(). Then set property values with .Modify() and finally call .Execute() to run the command.</para>
     /// </summary>
     /// <typeparam name="T">Any class that implements IEntity</typeparam>
-    public class UpdateAndGet<T> : UpdateAndGet<T, T> where T : IEntity
+    /// <typeparam name="TId">ID type</typeparam>
+    public class UpdateAndGet<T, TId> : UpdateAndGet<T, TId, T>
+        where TId : IComparable<TId>, IEquatable<TId>
+        where T : IEntity<TId>
     {
-        internal UpdateAndGet(DBContext context, IMongoCollection<T> collection, UpdateBase<T, UpdateAndGet<T, T>> other) : base(context, collection, other)
+        internal UpdateAndGet(DBContext context, IMongoCollection<T> collection, UpdateBase<T, TId, UpdateAndGet<T, TId, T>> other) : base(context, collection, other)
         {
         }
 
-        internal UpdateAndGet(DBContext context, IMongoCollection<T> collection, Action<UpdateAndGet<T, T>>? onUpdateAction, List<UpdateDefinition<T>>? defs) : base(context, collection, onUpdateAction, defs)
+        internal UpdateAndGet(DBContext context, IMongoCollection<T> collection, Action<UpdateAndGet<T, TId, T>>? onUpdateAction, List<UpdateDefinition<T>>? defs) : base(context, collection, onUpdateAction, defs)
         {
         }
     }
@@ -31,7 +34,10 @@ internal UpdateAndGet(DBContext context, IMongoCollection<T> collection, Action<
     /// </summary>
     /// <typeparam name="T">Any class that implements IEntity</typeparam>
     /// <typeparam name="TProjection">The type to project to</typeparam>
-    public class UpdateAndGet<T, TProjection> : UpdateBase<T, UpdateAndGet<T, TProjection>>, ICollectionRelated<T> where T : IEntity
+    /// <typeparam name="TId">ID type</typeparam>
+    public class UpdateAndGet<T, TId, TProjection> : UpdateBase<T, TId, UpdateAndGet<T, TId, TProjection>>, ICollectionRelated<T>
+        where TId : IComparable<TId>, IEquatable<TId>
+        where T : IEntity<TId>
     {
         private readonly List<PipelineStageDefinition<T, TProjection>> _stages = new();
         private protected readonly FindOneAndUpdateOptions<T, TProjection> _options = new() { ReturnDocument = ReturnDocument.After };
@@ -39,13 +45,13 @@ public class UpdateAndGet<T, TProjection> : UpdateBase<T, UpdateAndGet<T, TProje
         public override DBContext Context { get; }
         public IMongoCollection<T> Collection { get; }
 
-        internal UpdateAndGet(DBContext context, IMongoCollection<T> collection, UpdateBase<T, UpdateAndGet<T, TProjection>> other) : base(other)
+        internal UpdateAndGet(DBContext context, IMongoCollection<T> collection, UpdateBase<T, TId, UpdateAndGet<T, TId, TProjection>> other) : base(other)
         {
             Context = context;
             Collection = collection;
         }
 
-        internal UpdateAndGet(DBContext context, IMongoCollection<T> collection, Action<UpdateAndGet<T, TProjection>>? onUpdateAction = null, List<UpdateDefinition<T>>? defs = null) : base(context.GlobalFilters, onUpdateAction, defs)
+        internal UpdateAndGet(DBContext context, IMongoCollection<T> collection, Action<UpdateAndGet<T, TId, TProjection>>? onUpdateAction = null, List<UpdateDefinition<T>>? defs = null) : base(context.GlobalFilters, onUpdateAction, defs)
         {
             Context = context;
             Collection = collection;
@@ -58,7 +64,7 @@ internal UpdateAndGet(DBContext context, IMongoCollection<T> collection, Action<
         /// <para>NOTE: pipeline updates and regular updates cannot be used together.</para>
         /// </summary>
         /// <param name="template">A Template object containing multiple pipeline stages</param>
-        public UpdateAndGet<T, TProjection> WithPipeline(Template template)
+        public UpdateAndGet<T, TId, TProjection> WithPipeline(Template template)
         {
             foreach (var stage in template.ToStages())
             {
@@ -73,7 +79,7 @@ public UpdateAndGet<T, TProjection> WithPipeline(Template template)
         /// <para>NOTE: pipeline updates and regular updates cannot be used together.</para>
         /// </summary>
         /// <param name="stage">{ $set: { FullName: { $concat: ['$Name', ' ', '$Surname'] } } }</param>
-        public UpdateAndGet<T, TProjection> WithPipelineStage(string stage)
+        public UpdateAndGet<T, TId, TProjection> WithPipelineStage(string stage)
         {
             _stages.Add(stage);
             return this;
@@ -84,7 +90,7 @@ public UpdateAndGet<T, TProjection> WithPipelineStage(string stage)
         /// <para>NOTE: pipeline updates and regular updates cannot be used together.</para>
         /// </summary>
         /// <param name="template">A Template object containing a pipeline stage</param>
-        public UpdateAndGet<T, TProjection> WithPipelineStage(Template template)
+        public UpdateAndGet<T, TId, TProjection> WithPipelineStage(Template template)
         {
             return WithPipelineStage(template.RenderToString());
         }
@@ -93,7 +99,7 @@ public UpdateAndGet<T, TProjection> WithPipelineStage(Template template)
         /// Specify an array filter to target nested entities for updates (use multiple times if needed).
         /// </summary>
         /// <param name="filter">{ 'x.SubProp': { $gte: 123 } }</param>
-        public UpdateAndGet<T, TProjection> WithArrayFilter(string filter)
+        public UpdateAndGet<T, TId, TProjection> WithArrayFilter(string filter)
         {
             ArrayFilterDefinition<T> def = filter;
 
@@ -109,7 +115,7 @@ public UpdateAndGet<T, TProjection> WithArrayFilter(string filter)
         /// Specify a single array filter using a Template to target nested entities for updates
         /// </summary>
         /// <param name="template"></param>
-        public UpdateAndGet<T, TProjection> WithArrayFilter(Template template)
+        public UpdateAndGet<T, TId, TProjection> WithArrayFilter(Template template)
         {
             WithArrayFilter(template.RenderToString());
             return this;
@@ -119,7 +125,7 @@ public UpdateAndGet<T, TProjection> WithArrayFilter(Template template)
         /// Specify multiple array filters with a Template to target nested entities for updates.
         /// </summary>
         /// <param name="template">The template with an array [...] of filters</param>
-        public UpdateAndGet<T, TProjection> WithArrayFilters(Template template)
+        public UpdateAndGet<T, TId, TProjection> WithArrayFilters(Template template)
         {
             var defs = template.ToArrayFilters<T>();
 
@@ -136,7 +142,7 @@ public UpdateAndGet<T, TProjection> WithArrayFilters(Template template)
         /// <para>TIP: Setting options is not required</para>
         /// </summary>
         /// <param name="option">x => x.OptionName = OptionValue</param>
-        public UpdateAndGet<T, TProjection> Option(Action<FindOneAndUpdateOptions<T, TProjection>> option)
+        public UpdateAndGet<T, TId, TProjection> Option(Action<FindOneAndUpdateOptions<T, TProjection>> option)
         {
             option(_options);
             return this;
@@ -146,7 +152,7 @@ public UpdateAndGet<T, TProjection> Option(Action<FindOneAndUpdateOptions<T, TPr
         /// Specify how to project the results using a lambda expression
         /// </summary>
         /// <param name="expression">x => new Test { PropName = x.Prop }</param>
-        public UpdateAndGet<T, TProjection> Project(Expression<Func<T, TProjection>> expression)
+        public UpdateAndGet<T, TId, TProjection> Project(Expression<Func<T, TProjection>> expression)
         {
             return Project(p => p.Expression(expression));
         }
@@ -155,7 +161,7 @@ public UpdateAndGet<T, TProjection> Project(Expression<Func<T, TProjection>> exp
         /// Specify how to project the results using a projection expression
         /// </summary>
         /// <param name="projection">p => p.Include("Prop1").Exclude("Prop2")</param>
-        public UpdateAndGet<T, TProjection> Project(Func<ProjectionDefinitionBuilder<T>, ProjectionDefinition<T, TProjection>> projection)
+        public UpdateAndGet<T, TId, TProjection> Project(Func<ProjectionDefinitionBuilder<T>, ProjectionDefinition<T, TProjection>> projection)
         {
             _options.Projection = projection(Builders<T>.Projection);
             return this;
@@ -165,7 +171,7 @@ public UpdateAndGet<T, TProjection> Project(Func<ProjectionDefinitionBuilder<T>,
         /// Specify to automatically include all properties marked with [BsonRequired] attribute on the entity in the final projection. 
         /// <para>HINT: this method should only be called after the .Project() method.</para>
         /// </summary>
-        public UpdateAndGet<T, TProjection> IncludeRequiredProps()
+        public UpdateAndGet<T, TId, TProjection> IncludeRequiredProps()
         {
             if (typeof(T) != typeof(TProjection))
                 throw new InvalidOperationException("IncludeRequiredProps() cannot be used when projecting to a different type.");
diff --git a/MongoDB.Entities/Core/Attributes.cs b/MongoDB.Entities/Core/Attributes.cs
index 06019c9ef..7fd269443 100644
--- a/MongoDB.Entities/Core/Attributes.cs
+++ b/MongoDB.Entities/Core/Attributes.cs
@@ -1,130 +1,123 @@
-using MongoDB.Bson;
-using MongoDB.Bson.Serialization;
-using MongoDB.Bson.Serialization.Attributes;
-using MongoDB.Bson.Serialization.Serializers;
-using System;
+namespace MongoDB.Entities;
+
+/// <summary>
+/// Use this attribute to ignore a property when persisting an entity to the database.
+/// </summary>
+[AttributeUsage(AttributeTargets.Property, AllowMultiple = false)]
+public class IgnoreAttribute : BsonIgnoreAttribute { }
+
+/// <summary>
+/// Use this attribute to ignore a property when persisting an entity to the database if the value is null/default.
+/// </summary>
+[AttributeUsage(AttributeTargets.Property, AllowMultiple = false)]
+public class IgnoreDefaultAttribute : BsonIgnoreIfDefaultAttribute { }
+
+/// <summary>
+/// Specifies the field name and/or the order of the persisted document.
+/// </summary>
+[AttributeUsage(AttributeTargets.Property, AllowMultiple = false)]
+public class FieldAttribute : BsonElementAttribute
+{
+    public FieldAttribute(int fieldOrder) { Order = fieldOrder; }
+    public FieldAttribute(string fieldName) : base(fieldName) { }
+    public FieldAttribute(string fieldName, int fieldOrder) : base(fieldName) { Order = fieldOrder; }
+}
 
-namespace MongoDB.Entities
+/// <summary>
+/// Indicates that this property is the owner side of a many-to-many relationship
+/// </summary>
+[AttributeUsage(AttributeTargets.Property, AllowMultiple = false)]
+public class OwnerSideAttribute : Attribute { }
+
+/// <summary>
+/// Indicates that this property is the inverse side of a many-to-many relationship
+/// </summary>
+[AttributeUsage(AttributeTargets.Property, AllowMultiple = false)]
+public class InverseSideAttribute : Attribute { }
+
+/// <summary>
+/// Specifies a custom MongoDB collection name for an entity type.
+/// </summary>
+[AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
+public class CollectionAttribute : Attribute
 {
-    /// <summary>
-    /// Use this attribute to ignore a property when persisting an entity to the database.
-    /// </summary>
-    [AttributeUsage(AttributeTargets.Property, AllowMultiple = false)]
-    public class IgnoreAttribute : BsonIgnoreAttribute { }
-
-    /// <summary>
-    /// Use this attribute to ignore a property when persisting an entity to the database if the value is null/default.
-    /// </summary>
-    [AttributeUsage(AttributeTargets.Property, AllowMultiple = false)]
-    public class IgnoreDefaultAttribute : BsonIgnoreIfDefaultAttribute { }
-
-    /// <summary>
-    /// Specifies the field name and/or the order of the persisted document.
-    /// </summary>
-    [AttributeUsage(AttributeTargets.Property, AllowMultiple = false)]
-    public class FieldAttribute : BsonElementAttribute
-    {
-        public FieldAttribute(int fieldOrder) { Order = fieldOrder; }
-        public FieldAttribute(string fieldName) : base(fieldName) { }
-        public FieldAttribute(string fieldName, int fieldOrder) : base(fieldName) { Order = fieldOrder; }
-    }
+    public string Name { get; }
 
-    /// <summary>
-    /// Indicates that this property is the owner side of a many-to-many relationship
-    /// </summary>
-    [AttributeUsage(AttributeTargets.Property, AllowMultiple = false)]
-    public class OwnerSideAttribute : Attribute { }
-
-    /// <summary>
-    /// Indicates that this property is the inverse side of a many-to-many relationship
-    /// </summary>
-    [AttributeUsage(AttributeTargets.Property, AllowMultiple = false)]
-    public class InverseSideAttribute : Attribute { }
-
-    /// <summary>
-    /// Specifies a custom MongoDB collection name for an entity type.
-    /// </summary>
-    [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
-    public class CollectionAttribute : Attribute
+    public CollectionAttribute(string name)
     {
-        public string Name { get; }
-
-        public CollectionAttribute(string name)
-        {
-            if (string.IsNullOrEmpty(name)) throw new ArgumentNullException(nameof(name));
-            Name = name;
-        }
+        if (string.IsNullOrEmpty(name)) throw new ArgumentNullException(nameof(name));
+        Name = name;
     }
+}
 
-    /// <summary>
-    /// Use this attribute on properties that you want to omit when using SavePreserving() instead of supplying an expression. 
-    /// TIP: These attribute decorations are only effective if you do not specify a preservation expression when calling SavePreserving() 
-    /// </summary>
-    [AttributeUsage(AttributeTargets.Property, AllowMultiple = false)]
-    public class PreserveAttribute : Attribute { }
-
-    /// <summary>
-    /// Properties that don't have this attribute will be omitted when using SavePreserving()
-    /// TIP: These attribute decorations are only effective if you do not specify a preservation expression when calling SavePreserving()
-    /// </summary>
-    [AttributeUsage(AttributeTargets.Property, AllowMultiple = false)]
-    public class DontPreserveAttribute : Attribute { }
-
-    /// <summary>
-    /// Use this attribute to mark a property in order to save it in MongoDB server as ObjectId
-    /// </summary>
-    [AttributeUsage(AttributeTargets.Property, AllowMultiple = false)]
-    public class ObjectIdAttribute : BsonRepresentationAttribute
-    {
-        public ObjectIdAttribute() : base(BsonType.ObjectId)
-        { }
-    }
+/// <summary>
+/// Use this attribute on properties that you want to omit when using SavePreserving() instead of supplying an expression. 
+/// TIP: These attribute decorations are only effective if you do not specify a preservation expression when calling SavePreserving() 
+/// </summary>
+[AttributeUsage(AttributeTargets.Property, AllowMultiple = false)]
+public class PreserveAttribute : Attribute { }
+
+/// <summary>
+/// Properties that don't have this attribute will be omitted when using SavePreserving()
+/// TIP: These attribute decorations are only effective if you do not specify a preservation expression when calling SavePreserving()
+/// </summary>
+[AttributeUsage(AttributeTargets.Property, AllowMultiple = false)]
+public class DontPreserveAttribute : Attribute { }
+
+/// <summary>
+/// Use this attribute to mark a property in order to save it in MongoDB server as ObjectId
+/// </summary>
+[AttributeUsage(AttributeTargets.Property, AllowMultiple = false)]
+public class ObjectIdAttribute : BsonRepresentationAttribute
+{
+    public ObjectIdAttribute() : base(BsonType.ObjectId)
+    { }
+}
 
-    /// <summary>
-    /// Use this attribute to mark a string property to store the value in MongoDB as ObjectID if it is a valid ObjectId string. 
-    /// If it is not a valid ObjectId string, it will be stored as string. This is useful when using custom formats for the ID field.
-    /// </summary>
-    [AttributeUsage(AttributeTargets.Property, AllowMultiple = false)]
-    public class AsObjectIdAttribute : BsonSerializerAttribute
-    {
-        public AsObjectIdAttribute() : base(typeof(ObjectIdSerializer)) { }
+/// <summary>
+/// Use this attribute to mark a string property to store the value in MongoDB as ObjectID if it is a valid ObjectId string. 
+/// If it is not a valid ObjectId string, it will be stored as string. This is useful when using custom formats for the ID field.
+/// </summary>
+[AttributeUsage(AttributeTargets.Property, AllowMultiple = false)]
+public class AsObjectIdAttribute : BsonSerializerAttribute
+{
+    public AsObjectIdAttribute() : base(typeof(ObjectIdSerializer)) { }
 
-        private class ObjectIdSerializer : SerializerBase<string>
+    private class ObjectIdSerializer : SerializerBase<string?>
+    {
+        public override void Serialize(BsonSerializationContext ctx, BsonSerializationArgs args, string? value)
         {
-            public override void Serialize(BsonSerializationContext ctx, BsonSerializationArgs args, string value)
+            if (value is null)
+            {
+                ctx.Writer.WriteNull();
+                return;
+            }
+
+            if (value.Length == 24 && ObjectId.TryParse(value, out var oID))
             {
-                if (value == null)
-                {
-                    ctx.Writer.WriteNull();
-                    return;
-                }
-
-                if (value.Length == 24 && ObjectId.TryParse(value, out var oID))
-                {
-                    ctx.Writer.WriteObjectId(oID);
-                    return;
-                }
-
-                ctx.Writer.WriteString(value);
+                ctx.Writer.WriteObjectId(oID);
+                return;
             }
 
-            public override string Deserialize(BsonDeserializationContext ctx, BsonDeserializationArgs args)
+            ctx.Writer.WriteString(value);
+        }
+
+        public override string? Deserialize(BsonDeserializationContext ctx, BsonDeserializationArgs args)
+        {
+            switch (ctx.Reader.CurrentBsonType)
             {
-                switch (ctx.Reader.CurrentBsonType)
-                {
-                    case BsonType.String:
-                        return ctx.Reader.ReadString();
+                case BsonType.String:
+                    return ctx.Reader.ReadString();
 
-                    case BsonType.ObjectId:
-                        return ctx.Reader.ReadObjectId().ToString();
+                case BsonType.ObjectId:
+                    return ctx.Reader.ReadObjectId().ToString();
 
-                    case BsonType.Null:
-                        ctx.Reader.ReadNull();
-                        return null;
+                case BsonType.Null:
+                    ctx.Reader.ReadNull();
+                    return default;
 
-                    default:
-                        throw new BsonSerializationException($"'{ctx.Reader.CurrentBsonType}' values are not valid on properties decorated with an [AsObjectId] attribute!");
-                }
+                default:
+                    throw new BsonSerializationException($"'{ctx.Reader.CurrentBsonType}' values are not valid on properties decorated with an [AsObjectId] attribute!");
             }
         }
     }
diff --git a/MongoDB.Entities/Core/DBContextOptions.cs b/MongoDB.Entities/Core/DBContextOptions.cs
index db734ce92..a289b1ae9 100644
--- a/MongoDB.Entities/Core/DBContextOptions.cs
+++ b/MongoDB.Entities/Core/DBContextOptions.cs
@@ -1,12 +1,7 @@
-#nullable enable
+namespace MongoDB.Entities;
 
-using MongoDB.Driver;
-
-namespace MongoDB.Entities
+public class DBContextOptions
 {
-    public class DBContextOptions
-    {
-        
-        
-    }
+
+
 }
diff --git a/MongoDB.Entities/Core/Date.cs b/MongoDB.Entities/Core/Date.cs
index 572d0591d..f8e3f1409 100644
--- a/MongoDB.Entities/Core/Date.cs
+++ b/MongoDB.Entities/Core/Date.cs
@@ -1,109 +1,103 @@
-using MongoDB.Bson;
-using MongoDB.Bson.IO;
-using MongoDB.Bson.Serialization;
-using MongoDB.Bson.Serialization.Serializers;
-using System;
+using MongoDB.Bson.IO;
 
-namespace MongoDB.Entities
+namespace MongoDB.Entities;
+
+internal class DateSerializer : SerializerBase<Date?>, IBsonDocumentSerializer
 {
-    internal class DateSerializer : SerializerBase<Date>, IBsonDocumentSerializer
-    {
-        private static readonly Int64Serializer longSerializer = new();
-        private static readonly DateTimeSerializer dtSerializer = new();
+    private static readonly Int64Serializer _longSerializer = new();
+    private static readonly DateTimeSerializer _dtSerializer = new();
 
-        public override void Serialize(BsonSerializationContext ctx, BsonSerializationArgs args, Date date)
+    public override void Serialize(BsonSerializationContext ctx, BsonSerializationArgs args, Date? date)
+    {
+        if (date == null)
         {
-            if (date == null)
-            {
-                ctx.Writer.WriteNull();
-            }
-            else
-            {
-                var dtUTC = BsonUtils.ToUniversalTime(date.DateTime);
-                ctx.Writer.WriteStartDocument();
-                ctx.Writer.WriteDateTime("DateTime", BsonUtils.ToMillisecondsSinceEpoch(dtUTC));
-                ctx.Writer.WriteInt64("Ticks", dtUTC.Ticks);
-                ctx.Writer.WriteEndDocument();
-            }
+            ctx.Writer.WriteNull();
         }
-
-        public override Date Deserialize(BsonDeserializationContext ctx, BsonDeserializationArgs args)
+        else
         {
-            var bsonType = ctx.Reader.GetCurrentBsonType();
+            var dtUTC = BsonUtils.ToUniversalTime(date.DateTime);
+            ctx.Writer.WriteStartDocument();
+            ctx.Writer.WriteDateTime(nameof(Date.DateTime), BsonUtils.ToMillisecondsSinceEpoch(dtUTC));
+            ctx.Writer.WriteInt64(nameof(Date.Ticks), dtUTC.Ticks);
+            ctx.Writer.WriteEndDocument();
+        }
+    }
 
-            switch (bsonType)
-            {
-                case BsonType.Document:
+    public override Date? Deserialize(BsonDeserializationContext ctx, BsonDeserializationArgs args)
+    {
+        var bsonType = ctx.Reader.GetCurrentBsonType();
 
-                    long ticks = 0;
+        switch (bsonType)
+        {
+            case BsonType.Document:
 
-                    ctx.Reader.ReadStartDocument();
-                    while (ctx.Reader.ReadBsonType() != BsonType.EndOfDocument)
-                    {
-                        if (ctx.Reader.ReadName() == "Ticks")
-                            ticks = ctx.Reader.ReadInt64();
-                        else
-                            ctx.Reader.SkipValue();
-                    }
-                    ctx.Reader.ReadEndDocument();
+                long ticks = 0;
 
-                    return new Date() { DateTime = new DateTime(ticks, DateTimeKind.Utc) };
+                ctx.Reader.ReadStartDocument();
+                while (ctx.Reader.ReadBsonType() != BsonType.EndOfDocument)
+                {
+                    if (ctx.Reader.ReadName() == nameof(Date.Ticks))
+                        ticks = ctx.Reader.ReadInt64();
+                    else
+                        ctx.Reader.SkipValue();
+                }
+                ctx.Reader.ReadEndDocument();
 
-                case BsonType.Null:
-                    ctx.Reader.ReadNull();
-                    return null;
+                return new Date() { DateTime = new DateTime(ticks, DateTimeKind.Utc) };
 
-                default:
-                    throw new FormatException($"Cannot deserialize a 'Date' from a [{bsonType}]");
-            }
-        }
+            case BsonType.Null:
+                ctx.Reader.ReadNull();
+                return null;
 
-        public bool TryGetMemberSerializationInfo(string memberName, out BsonSerializationInfo serializationInfo)
-        {
-            switch (memberName)
-            {
-                case "Ticks":
-                    serializationInfo = new BsonSerializationInfo("Ticks", longSerializer, typeof(long));
-                    return true;
-                case "DateTime":
-                    serializationInfo = new BsonSerializationInfo("DateTime", dtSerializer, typeof(DateTime));
-                    return true;
-                default:
-                    serializationInfo = null;
-                    return false;
-            }
+            default:
+                throw new FormatException($"Cannot deserialize a 'Date' from a [{bsonType}]");
         }
     }
 
-    /// <summary>
-    /// A custom date/time type for precision datetime handling
-    /// </summary>
-    public class Date
+    public bool TryGetMemberSerializationInfo(string memberName, out BsonSerializationInfo? serializationInfo)
     {
-        private long ticks;
-        private DateTime date = new();
-
-        public long Ticks
+        switch (memberName)
         {
-            get => ticks;
-            set { date = new DateTime(value); ticks = value; }
+            case nameof(Date.Ticks):
+                serializationInfo = new BsonSerializationInfo(nameof(Date.Ticks), _longSerializer, typeof(long));
+                return true;
+            case nameof(Date.DateTime):
+                serializationInfo = new BsonSerializationInfo(nameof(Date.DateTime), _dtSerializer, typeof(DateTime));
+                return true;
+            default:
+                serializationInfo = null;
+                return false;
         }
+    }
+}
 
-        public DateTime DateTime
-        {
-            get => date;
-            set { date = value; ticks = value.Ticks; }
-        }
+/// <summary>
+/// A custom date/time type for precision datetime handling
+/// </summary>
+public class Date
+{
+    private long _ticks;
+    private DateTime _date = new();
 
-        public static implicit operator Date(DateTime datetime)
-        {
-            return new Date { DateTime = datetime };
-        }
+    public long Ticks
+    {
+        get => _ticks;
+        set { _date = new DateTime(value); _ticks = value; }
+    }
 
-        public static implicit operator DateTime(Date date)
-        {
-            if (date == null) throw new NullReferenceException("The [Date] instance is Null!");
-            return new DateTime(date.Ticks);
-        }
+    public DateTime DateTime
+    {
+        get => _date;
+        set { _date = value; _ticks = value.Ticks; }
+    }
+
+    public static implicit operator Date(DateTime datetime)
+    {
+        return new Date { DateTime = datetime };
+    }
+
+    public static implicit operator DateTime(Date date)
+    {
+        return new DateTime(date.Ticks);
     }
 }
diff --git a/MongoDB.Entities/Core/DoubleMetaphone.cs b/MongoDB.Entities/Core/DoubleMetaphone.cs
index 5ea650970..06b0fc087 100644
--- a/MongoDB.Entities/Core/DoubleMetaphone.cs
+++ b/MongoDB.Entities/Core/DoubleMetaphone.cs
@@ -1,765 +1,764 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
+using System.Text;
 using System.Text.RegularExpressions;
 
-namespace MongoDB.Entities
+#pragma warning disable IDE1006 // Naming Styles
+
+namespace MongoDB.Entities;
+
+internal static class DoubleMetaphone
 {
-    internal static class DoubleMetaphone
+    private static readonly string[] GN_KN_PN_WR_PS = new[] { "GN", "KN", "PN", "WR", "PS" };
+    private static readonly string[] ACH = new[] { "ACH" };
+    private static readonly string[] BACHER_MACHER = new[] { "BACHER", "MACHER" };
+    private static readonly string[] CAESAR = new[] { "CAESAR" };
+    private static readonly string[] CHIA = new[] { "CHIA" };
+    private static readonly string[] CH = new[] { "CH" };
+    private static readonly string[] CHAE = new[] { "CHAE" };
+    private static readonly string[] HARAC_HARIS_HOR_HYM_HIA_HEM = new[] { "HARAC", "HARIS", "HOR", "HYM", "HIA", "HEM" };
+    private static readonly string[] CHORE = new[] { "CHORE" };
+    private static readonly string[] SCH = new[] { "SCH" };
+    private static readonly string[] VAN__VON__SCH = new[] { "VAN ", "VON ", "SCH" };
+    private static readonly string[] ORCHES_ARCHIT_ORCHID = new[] { "ORCHES", "ARCHIT", "ORCHID" };
+    private static readonly string[] T_S = new[] { "T", "S" };
+    private static readonly string[] A_O = new[] { "A", "O" };
+    private static readonly string[] A_O_U_E = new[] { "A", "O", "U", "E" };
+    private static readonly string[] L_R_N_M_B_H_F_V_W__ = new[] { "L", "R", "N", "M", "B", "H", "F", "V", "W", " " };
+    private static readonly string[] MC = new[] { "MC" };
+    private static readonly string[] CZ = new[] { "CZ" };
+    private static readonly string[] WICZ = new[] { "WICZ" };
+    private static readonly string[] CIA = new[] { "CIA" };
+    private static readonly string[] CC = new[] { "CC" };
+    private static readonly string[] I_E_H = new[] { "I", "E", "H" };
+    private static readonly string[] HU = new[] { "HU" };
+    private static readonly string[] UCCEE_UCCES = new[] { "UCCEE", "UCCES" };
+    private static readonly string[] CK_CG_CQ = new[] { "CK", "CG", "CQ" };
+    private static readonly string[] CI_CE_CY = new[] { "CI", "CE", "CY" };
+    private static readonly string[] CIO_CIE_CIA = new[] { "CIO", "CIE", "CIA" };
+    private static readonly string[] _C__Q__G = new[] { " C", " Q", " G" };
+    private static readonly string[] C_K_Q = new[] { "C", "K", "Q" };
+    private static readonly string[] CE_CI = new[] { "CE", "CI" };
+    private static readonly string[] DG = new[] { "DG" };
+    private static readonly string[] I_E_Y = new[] { "I", "E", "Y" };
+    private static readonly string[] DT_DD = new[] { "DT", "DD" };
+    private static readonly string[] B_H_D = new[] { "B", "H", "D" };
+    private static readonly string[] B_H = new[] { "B", "H" };
+    private static readonly string[] C_G_L_R_T = new[] { "C", "G", "L", "R", "T" };
+    private static readonly string[] EY = new[] { "EY" };
+    private static readonly string[] LI = new[] { "LI" };
+    private static readonly string[] Y_ES_EP_EB_EL_EY_IB_IL_IN_IE_EI_ER = new[] { "Y", "ES", "EP", "EB", "EL", "EY", "IB", "IL", "IN", "IE", "EI", "ER" };
+    private static readonly string[] Y_ER = new[] { "Y", "ER" };
+    private static readonly string[] DANGER_RANGER_MANGER = new[] { "DANGER", "RANGER", "MANGER" };
+    private static readonly string[] E_I = new[] { "E", "I" };
+    private static readonly string[] RGY_OGY = new[] { "RGY", "OGY" };
+    private static readonly string[] E_I_Y = new[] { "E", "I", "Y" };
+    private static readonly string[] AGGI_OGGI = new[] { "AGGI", "OGGI" };
+    private static readonly string[] ET = new[] { "ET" };
+    private static readonly string[] JOSE = new[] { "JOSE" };
+    private static readonly string[] SAN_ = new[] { "SAN " };
+    private static readonly string[] L_T_K_S_N_M_B_Z = new[] { "L", "T", "K", "S", "N", "M", "B", "Z" };
+    private static readonly string[] S_K_L = new[] { "S", "K", "L" };
+    private static readonly string[] ILLO_ILLA_ALLE = new[] { "ILLO", "ILLA", "ALLE" };
+    private static readonly string[] AS_OS = new[] { "AS", "OS" };
+    private static readonly string[] ALLE = new[] { "ALLE" };
+    private static readonly string[] UMB = new[] { "UMB" };
+    private static readonly string[] P_B = new[] { "P", "B" };
+    private static readonly string[] IE = new[] { "IE" };
+    private static readonly string[] IER = new[] { "IER" };
+    private static readonly string[] ER = new[] { "ER" };
+    private static readonly string[] ME_MA = new[] { "ME", "MA" };
+    private static readonly string[] ISL_YSL = new[] { "ISL", "YSL" };
+    private static readonly string[] SUGAR = new[] { "SUGAR" };
+    private static readonly string[] SH = new[] { "SH" };
+    private static readonly string[] HEIM_HOEK_HOLM_HOLZ = new[] { "HEIM", "HOEK", "HOLM", "HOLZ" };
+    private static readonly string[] SIO_SIA = new[] { "SIO", "SIA" };
+    private static readonly string[] SIAN = new[] { "SIAN" };
+    private static readonly string[] M_N_L_W = new[] { "M", "N", "L", "W" };
+    private static readonly string[] SC = new[] { "SC" };
+    private static readonly string[] OO_ER_EN_UY_ED_EM = new[] { "OO", "ER", "EN", "UY", "ED", "EM" };
+    private static readonly string[] ER_EN = new[] { "ER", "EN" };
+    private static readonly string[] AI_OI = new[] { "AI", "OI" };
+    private static readonly string[] S_Z = new[] { "S", "Z" };
+    private static readonly string[] TION = new[] { "TION" };
+    private static readonly string[] TIA_TCH = new[] { "TIA", "TCH" };
+    private static readonly string[] TH_TTH = new[] { "TH", "TTH" };
+    private static readonly string[] OM_AM = new[] { "OM", "AM" };
+    private static readonly string[] T_D = new[] { "T", "D" };
+    private static readonly string[] WR = new[] { "WR" };
+    private static readonly string[] WH = new[] { "WH" };
+    private static readonly string[] EWSKI_EWSKY_OWSKI_OWSKY = new[] { "EWSKI", "EWSKY", "OWSKI", "OWSKY" };
+    private static readonly string[] WICZ_WITZ = new[] { "WICZ", "WITZ" };
+    private static readonly string[] IAU_EAU = new[] { "IAU", "EAU" };
+    private static readonly string[] AU_OU = new[] { "AU", "OU" };
+    private static readonly string[] C_X = new[] { "C", "X" };
+    private static readonly string[] ZO_ZI_ZA = new[] { "ZO", "ZI", "ZA" };
+
+    private static readonly string[] EmptyKeys = new string[0];
+    private const int MaxLength = 4;
+
+    private static readonly Regex regex = new(@"\w(?<!\d)[\w'-]*", RegexOptions.Compiled);
+
+    private static void Add(string main, ref StringBuilder sbPrimary, ref StringBuilder sbSecondary)
+    {
+        sbPrimary.Append(main);
+        sbSecondary.Append(main);
+    }
+
+    private static void Add(string main, string alternate, ref StringBuilder sbPrimary, ref StringBuilder sbSecondary, ref bool hasAlternate)
     {
-        private static readonly string[] GN_KN_PN_WR_PS = new[] { "GN", "KN", "PN", "WR", "PS" };
-        private static readonly string[] ACH = new[] { "ACH" };
-        private static readonly string[] BACHER_MACHER = new[] { "BACHER", "MACHER" };
-        private static readonly string[] CAESAR = new[] { "CAESAR" };
-        private static readonly string[] CHIA = new[] { "CHIA" };
-        private static readonly string[] CH = new[] { "CH" };
-        private static readonly string[] CHAE = new[] { "CHAE" };
-        private static readonly string[] HARAC_HARIS_HOR_HYM_HIA_HEM = new[] { "HARAC", "HARIS", "HOR", "HYM", "HIA", "HEM" };
-        private static readonly string[] CHORE = new[] { "CHORE" };
-        private static readonly string[] SCH = new[] { "SCH" };
-        private static readonly string[] VAN__VON__SCH = new[] { "VAN ", "VON ", "SCH" };
-        private static readonly string[] ORCHES_ARCHIT_ORCHID = new[] { "ORCHES", "ARCHIT", "ORCHID" };
-        private static readonly string[] T_S = new[] { "T", "S" };
-        private static readonly string[] A_O = new[] { "A", "O" };
-        private static readonly string[] A_O_U_E = new[] { "A", "O", "U", "E" };
-        private static readonly string[] L_R_N_M_B_H_F_V_W__ = new[] { "L", "R", "N", "M", "B", "H", "F", "V", "W", " " };
-        private static readonly string[] MC = new[] { "MC" };
-        private static readonly string[] CZ = new[] { "CZ" };
-        private static readonly string[] WICZ = new[] { "WICZ" };
-        private static readonly string[] CIA = new[] { "CIA" };
-        private static readonly string[] CC = new[] { "CC" };
-        private static readonly string[] I_E_H = new[] { "I", "E", "H" };
-        private static readonly string[] HU = new[] { "HU" };
-        private static readonly string[] UCCEE_UCCES = new[] { "UCCEE", "UCCES" };
-        private static readonly string[] CK_CG_CQ = new[] { "CK", "CG", "CQ" };
-        private static readonly string[] CI_CE_CY = new[] { "CI", "CE", "CY" };
-        private static readonly string[] CIO_CIE_CIA = new[] { "CIO", "CIE", "CIA" };
-        private static readonly string[] _C__Q__G = new[] { " C", " Q", " G" };
-        private static readonly string[] C_K_Q = new[] { "C", "K", "Q" };
-        private static readonly string[] CE_CI = new[] { "CE", "CI" };
-        private static readonly string[] DG = new[] { "DG" };
-        private static readonly string[] I_E_Y = new[] { "I", "E", "Y" };
-        private static readonly string[] DT_DD = new[] { "DT", "DD" };
-        private static readonly string[] B_H_D = new[] { "B", "H", "D" };
-        private static readonly string[] B_H = new[] { "B", "H" };
-        private static readonly string[] C_G_L_R_T = new[] { "C", "G", "L", "R", "T" };
-        private static readonly string[] EY = new[] { "EY" };
-        private static readonly string[] LI = new[] { "LI" };
-        private static readonly string[] Y_ES_EP_EB_EL_EY_IB_IL_IN_IE_EI_ER = new[] { "Y", "ES", "EP", "EB", "EL", "EY", "IB", "IL", "IN", "IE", "EI", "ER" };
-        private static readonly string[] Y_ER = new[] { "Y", "ER" };
-        private static readonly string[] DANGER_RANGER_MANGER = new[] { "DANGER", "RANGER", "MANGER" };
-        private static readonly string[] E_I = new[] { "E", "I" };
-        private static readonly string[] RGY_OGY = new[] { "RGY", "OGY" };
-        private static readonly string[] E_I_Y = new[] { "E", "I", "Y" };
-        private static readonly string[] AGGI_OGGI = new[] { "AGGI", "OGGI" };
-        private static readonly string[] ET = new[] { "ET" };
-        private static readonly string[] JOSE = new[] { "JOSE" };
-        private static readonly string[] SAN_ = new[] { "SAN " };
-        private static readonly string[] L_T_K_S_N_M_B_Z = new[] { "L", "T", "K", "S", "N", "M", "B", "Z" };
-        private static readonly string[] S_K_L = new[] { "S", "K", "L" };
-        private static readonly string[] ILLO_ILLA_ALLE = new[] { "ILLO", "ILLA", "ALLE" };
-        private static readonly string[] AS_OS = new[] { "AS", "OS" };
-        private static readonly string[] ALLE = new[] { "ALLE" };
-        private static readonly string[] UMB = new[] { "UMB" };
-        private static readonly string[] P_B = new[] { "P", "B" };
-        private static readonly string[] IE = new[] { "IE" };
-        private static readonly string[] IER = new[] { "IER" };
-        private static readonly string[] ER = new[] { "ER" };
-        private static readonly string[] ME_MA = new[] { "ME", "MA" };
-        private static readonly string[] ISL_YSL = new[] { "ISL", "YSL" };
-        private static readonly string[] SUGAR = new[] { "SUGAR" };
-        private static readonly string[] SH = new[] { "SH" };
-        private static readonly string[] HEIM_HOEK_HOLM_HOLZ = new[] { "HEIM", "HOEK", "HOLM", "HOLZ" };
-        private static readonly string[] SIO_SIA = new[] { "SIO", "SIA" };
-        private static readonly string[] SIAN = new[] { "SIAN" };
-        private static readonly string[] M_N_L_W = new[] { "M", "N", "L", "W" };
-        private static readonly string[] SC = new[] { "SC" };
-        private static readonly string[] OO_ER_EN_UY_ED_EM = new[] { "OO", "ER", "EN", "UY", "ED", "EM" };
-        private static readonly string[] ER_EN = new[] { "ER", "EN" };
-        private static readonly string[] AI_OI = new[] { "AI", "OI" };
-        private static readonly string[] S_Z = new[] { "S", "Z" };
-        private static readonly string[] TION = new[] { "TION" };
-        private static readonly string[] TIA_TCH = new[] { "TIA", "TCH" };
-        private static readonly string[] TH_TTH = new[] { "TH", "TTH" };
-        private static readonly string[] OM_AM = new[] { "OM", "AM" };
-        private static readonly string[] T_D = new[] { "T", "D" };
-        private static readonly string[] WR = new[] { "WR" };
-        private static readonly string[] WH = new[] { "WH" };
-        private static readonly string[] EWSKI_EWSKY_OWSKI_OWSKY = new[] { "EWSKI", "EWSKY", "OWSKI", "OWSKY" };
-        private static readonly string[] WICZ_WITZ = new[] { "WICZ", "WITZ" };
-        private static readonly string[] IAU_EAU = new[] { "IAU", "EAU" };
-        private static readonly string[] AU_OU = new[] { "AU", "OU" };
-        private static readonly string[] C_X = new[] { "C", "X" };
-        private static readonly string[] ZO_ZI_ZA = new[] { "ZO", "ZI", "ZA" };
-
-        private static readonly string[] EmptyKeys = new string[0];
-        private const int MaxLength = 4;
-
-        private static readonly Regex regex = new(@"\w(?<!\d)[\w'-]*", RegexOptions.Compiled);
-
-        private static void Add(string main, ref StringBuilder sbPrimary, ref StringBuilder sbSecondary)
+        sbPrimary.Append(main);
+        if (alternate.Length > 0)
         {
-            sbPrimary.Append(main);
-            sbSecondary.Append(main);
+            hasAlternate = true;
+            if (!alternate.Equals(" "))
+                sbSecondary.Append(alternate);
         }
-
-        private static void Add(string main, string alternate, ref StringBuilder sbPrimary, ref StringBuilder sbSecondary, ref bool hasAlternate)
+        else
         {
-            sbPrimary.Append(main);
-            if (alternate.Length > 0)
-            {
-                hasAlternate = true;
-                if (!alternate.Equals(" "))
-                    sbSecondary.Append(alternate);
-            }
-            else
-            {
-                if (main.Length > 0 && !main.Equals(" "))
-                    sbSecondary.Append(main);
-            }
+            if (main.Length > 0 && !main.Equals(" "))
+                sbSecondary.Append(main);
         }
+    }
 
-        private static bool Match(string stringRenamed, int pos, string[] strings)
+    private static bool Match(string stringRenamed, int pos, string[] strings)
+    {
+        if (0 <= pos && pos < stringRenamed.Length)
         {
-            if (0 <= pos && pos < stringRenamed.Length)
+            for (int n = strings.Length - 1; n >= 0; n--)
             {
-                for (int n = strings.Length - 1; n >= 0; n--)
-                {
-                    if (string.Compare(stringRenamed, pos, strings[n], 0, strings[n].Length) == 0)
-                        return true;
-                }
+                if (string.Compare(stringRenamed, pos, strings[n], 0, strings[n].Length) == 0)
+                    return true;
             }
-            return false;
         }
+        return false;
+    }
 
-        private static bool Match(string stringRenamed, int pos, char c)
-        {
-            return 0 <= pos && pos < stringRenamed.Length && stringRenamed[pos] == c;
-        }
+    private static bool Match(string stringRenamed, int pos, char c)
+    {
+        return 0 <= pos && pos < stringRenamed.Length && stringRenamed[pos] == c;
+    }
 
-        private static bool IsSlavoGermanic(string stringRenamed)
-        {
-            return (stringRenamed.IndexOf('W') >= 0) || (stringRenamed.IndexOf('K') >= 0) || (stringRenamed.IndexOf("CZ", StringComparison.Ordinal) >= 0) || (stringRenamed.IndexOf("WITZ", StringComparison.Ordinal) >= 0);
-        }
+    private static bool IsSlavoGermanic(string stringRenamed)
+    {
+        return (stringRenamed.IndexOf('W') >= 0) || (stringRenamed.IndexOf('K') >= 0) || (stringRenamed.IndexOf("CZ", StringComparison.Ordinal) >= 0) || (stringRenamed.IndexOf("WITZ", StringComparison.Ordinal) >= 0);
+    }
 
-        private static bool IsVowel(string stringRenamed, int pos)
-        {
-            if (pos < 0 || stringRenamed.Length <= pos)
-                return false;
+    private static bool IsVowel(string stringRenamed, int pos)
+    {
+        if (pos < 0 || stringRenamed.Length <= pos)
+            return false;
 
-            char c = stringRenamed[pos];
-            return c == 'A' || c == 'E' || c == 'I' || c == 'O' || c == 'U';
-        }
+        char c = stringRenamed[pos];
+        return c == 'A' || c == 'E' || c == 'I' || c == 'O' || c == 'U';
+    }
 
-        private static string[] BuildKeys(string word)
-        {
-            if (string.IsNullOrEmpty(word))
-                return EmptyKeys;
+    private static string[] BuildKeys(string word)
+    {
+        if (string.IsNullOrEmpty(word))
+            return EmptyKeys;
 
-            word = word.ToUpper();
+        word = word.ToUpper();
 
-            var sbPrimary = new StringBuilder(word.Length);
-            var sbSecondary = new StringBuilder(word.Length);
-            bool hasAlternate = false;
-            int length = word.Length;
-            int last = length - 1;
-            bool isSlavoGermanic = IsSlavoGermanic(word);
-            int n = 0;
+        var sbPrimary = new StringBuilder(word.Length);
+        var sbSecondary = new StringBuilder(word.Length);
+        bool hasAlternate = false;
+        int length = word.Length;
+        int last = length - 1;
+        bool isSlavoGermanic = IsSlavoGermanic(word);
+        int n = 0;
 
-            if (Match(word, 0, GN_KN_PN_WR_PS))
-                n++;
+        if (Match(word, 0, GN_KN_PN_WR_PS))
+            n++;
 
-            if (Match(word, 0, 'X'))
-            {
-                Add("S", ref sbPrimary, ref sbSecondary);
-                n++;
-            }
+        if (Match(word, 0, 'X'))
+        {
+            Add("S", ref sbPrimary, ref sbSecondary);
+            n++;
+        }
 
-            while (n < length && (MaxLength < 0 || (sbPrimary.Length < MaxLength && sbSecondary.Length < MaxLength)))
+        while (n < length && (MaxLength < 0 || (sbPrimary.Length < MaxLength && sbSecondary.Length < MaxLength)))
+        {
+            switch (word[n])
             {
-                switch (word[n])
-                {
-                    case 'A':
-                    case 'E':
-                    case 'I':
-                    case 'O':
-                    case 'U':
-                    case 'Y':
-                        if (n == 0)
-                            Add("A", ref sbPrimary, ref sbSecondary);
-                        n++;
-                        break;
-                    case 'B':
-                        Add("P", ref sbPrimary, ref sbSecondary);
-                        n += Match(word, n + 1, 'B') ? 2 : 1;
+                case 'A':
+                case 'E':
+                case 'I':
+                case 'O':
+                case 'U':
+                case 'Y':
+                    if (n == 0)
+                        Add("A", ref sbPrimary, ref sbSecondary);
+                    n++;
+                    break;
+                case 'B':
+                    Add("P", ref sbPrimary, ref sbSecondary);
+                    n += Match(word, n + 1, 'B') ? 2 : 1;
+                    break;
+                case 'Ç':
+                    Add("S", ref sbPrimary, ref sbSecondary);
+                    n++;
+                    break;
+                case 'C':
+                    if ((n > 1) && !IsVowel(word, n - 2) && Match(word, n - 1, ACH) && !Match(word, n + 2, 'I') && (!Match(word, n + 2, 'E') || Match(word, n - 2, BACHER_MACHER)))
+                    {
+                        Add("K", ref sbPrimary, ref sbSecondary);
+                        n += 2;
                         break;
-                    case 'Ç':
+                    }
+
+                    if ((n == 0) && Match(word, n, CAESAR))
+                    {
                         Add("S", ref sbPrimary, ref sbSecondary);
-                        n++;
+                        n += 2;
+                        break;
+                    }
+
+                    if (Match(word, n, CHIA))
+                    {
+                        Add("K", ref sbPrimary, ref sbSecondary);
+                        n += 2;
                         break;
-                    case 'C':
-                        if ((n > 1) && !IsVowel(word, n - 2) && Match(word, n - 1, ACH) && !Match(word, n + 2, 'I') && (!Match(word, n + 2, 'E') || Match(word, n - 2, BACHER_MACHER)))
+                    }
+
+                    if (Match(word, n, CH))
+                    {
+                        if ((n > 0) && Match(word, n, CHAE))
                         {
-                            Add("K", ref sbPrimary, ref sbSecondary);
+                            Add("K", "X", ref sbPrimary, ref sbSecondary, ref hasAlternate);
                             n += 2;
                             break;
                         }
 
-                        if ((n == 0) && Match(word, n, CAESAR))
+                        if ((n == 0) && Match(word, n + 1, HARAC_HARIS_HOR_HYM_HIA_HEM) && !Match(word, 0, CHORE))
                         {
-                            Add("S", ref sbPrimary, ref sbSecondary);
+                            Add("K", ref sbPrimary, ref sbSecondary);
                             n += 2;
                             break;
                         }
 
-                        if (Match(word, n, CHIA))
+                        if (Match(word, 0, VAN__VON__SCH) || Match(word, n - 2, ORCHES_ARCHIT_ORCHID) || Match(word, n + 2, T_S) || (((n == 0) || Match(word, n - 1, A_O_U_E)) && Match(word, n + 2, L_R_N_M_B_H_F_V_W__)))
                         {
                             Add("K", ref sbPrimary, ref sbSecondary);
-                            n += 2;
-                            break;
                         }
-
-                        if (Match(word, n, CH))
+                        else
                         {
-                            if ((n > 0) && Match(word, n, CHAE))
+                            if (n > 0)
                             {
-                                Add("K", "X", ref sbPrimary, ref sbSecondary, ref hasAlternate);
-                                n += 2;
-                                break;
-                            }
-
-                            if ((n == 0) && Match(word, n + 1, HARAC_HARIS_HOR_HYM_HIA_HEM) && !Match(word, 0, CHORE))
-                            {
-                                Add("K", ref sbPrimary, ref sbSecondary);
-                                n += 2;
-                                break;
-                            }
-
-                            if (Match(word, 0, VAN__VON__SCH) || Match(word, n - 2, ORCHES_ARCHIT_ORCHID) || Match(word, n + 2, T_S) || (((n == 0) || Match(word, n - 1, A_O_U_E)) && Match(word, n + 2, L_R_N_M_B_H_F_V_W__)))
-                            {
-                                Add("K", ref sbPrimary, ref sbSecondary);
+                                if (Match(word, 0, MC))
+                                    Add("K", ref sbPrimary, ref sbSecondary);
+                                else
+                                    Add("X", "K", ref sbPrimary, ref sbSecondary, ref hasAlternate);
                             }
                             else
                             {
-                                if (n > 0)
-                                {
-                                    if (Match(word, 0, MC))
-                                        Add("K", ref sbPrimary, ref sbSecondary);
-                                    else
-                                        Add("X", "K", ref sbPrimary, ref sbSecondary, ref hasAlternate);
-                                }
-                                else
-                                {
-                                    Add("X", ref sbPrimary, ref sbSecondary);
-                                }
+                                Add("X", ref sbPrimary, ref sbSecondary);
                             }
-                            n += 2;
-                            break;
-                        }
-
-                        if (Match(word, n, CZ) && !Match(word, n - 2, WICZ))
-                        {
-                            Add("S", "X", ref sbPrimary, ref sbSecondary, ref hasAlternate);
-                            n += 2;
-                            break;
-                        }
-
-                        if (Match(word, n + 1, CIA))
-                        {
-                            Add("X", ref sbPrimary, ref sbSecondary);
-                            n += 3;
-                            break;
                         }
+                        n += 2;
+                        break;
+                    }
 
-                        if (Match(word, n, CC) && !((n == 1) && Match(word, 0, 'M')))
-                        {
-                            if (Match(word, n + 2, I_E_H) && !Match(word, n + 2, HU))
-                            {
-                                if (((n == 1) && Match(word, n - 1, 'A')) || Match(word, n - 1, UCCEE_UCCES))
-                                    Add("KS", ref sbPrimary, ref sbSecondary);
-                                else
-                                    Add("X", ref sbPrimary, ref sbSecondary);
-                                n += 3;
-                                break;
-                            }
-                            Add("K", ref sbPrimary, ref sbSecondary);
-                            n += 2;
-                            break;
-                        }
+                    if (Match(word, n, CZ) && !Match(word, n - 2, WICZ))
+                    {
+                        Add("S", "X", ref sbPrimary, ref sbSecondary, ref hasAlternate);
+                        n += 2;
+                        break;
+                    }
 
-                        if (Match(word, n, CK_CG_CQ))
-                        {
-                            Add("K", ref sbPrimary, ref sbSecondary);
-                            n += 2;
-                            break;
-                        }
+                    if (Match(word, n + 1, CIA))
+                    {
+                        Add("X", ref sbPrimary, ref sbSecondary);
+                        n += 3;
+                        break;
+                    }
 
-                        if (Match(word, n, CI_CE_CY))
+                    if (Match(word, n, CC) && !((n == 1) && Match(word, 0, 'M')))
+                    {
+                        if (Match(word, n + 2, I_E_H) && !Match(word, n + 2, HU))
                         {
-                            if (Match(word, n, CIO_CIE_CIA))
-                                Add("S", "X", ref sbPrimary, ref sbSecondary, ref hasAlternate);
+                            if (((n == 1) && Match(word, n - 1, 'A')) || Match(word, n - 1, UCCEE_UCCES))
+                                Add("KS", ref sbPrimary, ref sbSecondary);
                             else
-                                Add("S", ref sbPrimary, ref sbSecondary);
-                            n += 2;
+                                Add("X", ref sbPrimary, ref sbSecondary);
+                            n += 3;
                             break;
                         }
+                        Add("K", ref sbPrimary, ref sbSecondary);
+                        n += 2;
+                        break;
+                    }
 
+                    if (Match(word, n, CK_CG_CQ))
+                    {
                         Add("K", ref sbPrimary, ref sbSecondary);
+                        n += 2;
+                        break;
+                    }
 
-                        if (Match(word, n + 1, _C__Q__G))
-                            n += 3;
+                    if (Match(word, n, CI_CE_CY))
+                    {
+                        if (Match(word, n, CIO_CIE_CIA))
+                            Add("S", "X", ref sbPrimary, ref sbSecondary, ref hasAlternate);
                         else
-                            n += (Match(word, n + 1, C_K_Q) && !Match(word, n + 1, CE_CI)) ? 2 : 1;
+                            Add("S", ref sbPrimary, ref sbSecondary);
+                        n += 2;
                         break;
+                    }
 
-                    case 'D':
-                        if (Match(word, n, DG))
-                        {
-                            if (Match(word, n + 2, I_E_Y))
-                            {
-                                Add("J", ref sbPrimary, ref sbSecondary);
-                                n += 3;
-                                break;
-                            }
-                            Add("TK", ref sbPrimary, ref sbSecondary);
-                            n += 2;
-                            break;
-                        }
+                    Add("K", ref sbPrimary, ref sbSecondary);
 
-                        if (Match(word, n, DT_DD))
+                    if (Match(word, n + 1, _C__Q__G))
+                        n += 3;
+                    else
+                        n += (Match(word, n + 1, C_K_Q) && !Match(word, n + 1, CE_CI)) ? 2 : 1;
+                    break;
+
+                case 'D':
+                    if (Match(word, n, DG))
+                    {
+                        if (Match(word, n + 2, I_E_Y))
                         {
-                            Add("T", ref sbPrimary, ref sbSecondary);
-                            n += 2;
+                            Add("J", ref sbPrimary, ref sbSecondary);
+                            n += 3;
                             break;
                         }
+                        Add("TK", ref sbPrimary, ref sbSecondary);
+                        n += 2;
+                        break;
+                    }
 
+                    if (Match(word, n, DT_DD))
+                    {
                         Add("T", ref sbPrimary, ref sbSecondary);
-                        n++;
+                        n += 2;
                         break;
-                    case 'F':
-                        n += Match(word, n + 1, 'F') ? 2 : 1;
-                        Add("F", ref sbPrimary, ref sbSecondary);
-                        break;
-                    case 'G':
-                        if (Match(word, n + 1, 'H'))
+                    }
+
+                    Add("T", ref sbPrimary, ref sbSecondary);
+                    n++;
+                    break;
+                case 'F':
+                    n += Match(word, n + 1, 'F') ? 2 : 1;
+                    Add("F", ref sbPrimary, ref sbSecondary);
+                    break;
+                case 'G':
+                    if (Match(word, n + 1, 'H'))
+                    {
+                        if ((n > 0) && !IsVowel(word, n - 1))
                         {
-                            if ((n > 0) && !IsVowel(word, n - 1))
-                            {
-                                Add("K", ref sbPrimary, ref sbSecondary);
-                                n += 2;
-                                break;
-                            }
-
-                            if (n < 3)
-                            {
-                                if (n == 0)
-                                {
-                                    Add(Match(word, n + 2, 'I') ? "J" : "K", ref sbPrimary, ref sbSecondary);
-                                    n += 2;
-                                    break;
-                                }
-                            }
-
-                            if (((n > 1) && Match(word, n - 2, B_H_D)) || ((n > 2) && Match(word, n - 3, B_H_D)) || ((n > 3) && Match(word, n - 4, B_H)))
-                            {
-                                n += 2;
-                                break;
-                            }
-                            if ((n > 2) && Match(word, n - 1, 'U') && Match(word, n - 3, C_G_L_R_T))
-                            {
-                                Add("F", ref sbPrimary, ref sbSecondary);
-                            }
-                            else if ((n > 0) && !Match(word, n - 1, 'I'))
-                            {
-                                Add("K", ref sbPrimary, ref sbSecondary);
-                            }
-
+                            Add("K", ref sbPrimary, ref sbSecondary);
                             n += 2;
                             break;
                         }
 
-                        if (Match(word, n + 1, 'N'))
+                        if (n < 3)
                         {
-                            if ((n == 1) && IsVowel(word, 0) && !isSlavoGermanic)
-                            {
-                                Add("KN", "N", ref sbPrimary, ref sbSecondary, ref hasAlternate);
-                            }
-                            else
+                            if (n == 0)
                             {
-                                if (!Match(word, n + 2, EY) && !Match(word, n + 1, 'Y') && !isSlavoGermanic)
-                                {
-                                    Add("N", "KN", ref sbPrimary, ref sbSecondary, ref hasAlternate);
-                                }
-                                else
-                                {
-                                    Add("KN", ref sbPrimary, ref sbSecondary);
-                                }
+                                Add(Match(word, n + 2, 'I') ? "J" : "K", ref sbPrimary, ref sbSecondary);
+                                n += 2;
+                                break;
                             }
-                            n += 2;
-                            break;
-                        }
-
-                        if (Match(word, n + 1, LI) && !isSlavoGermanic)
-                        {
-                            Add("KL", "L", ref sbPrimary, ref sbSecondary, ref hasAlternate);
-                            n += 2;
-                            break;
                         }
 
-                        if ((n == 0) && Match(word, n + 1, Y_ES_EP_EB_EL_EY_IB_IL_IN_IE_EI_ER))
+                        if (((n > 1) && Match(word, n - 2, B_H_D)) || ((n > 2) && Match(word, n - 3, B_H_D)) || ((n > 3) && Match(word, n - 4, B_H)))
                         {
-                            Add("K", "J", ref sbPrimary, ref sbSecondary, ref hasAlternate);
                             n += 2;
                             break;
                         }
-
-                        if (Match(word, n + 1, Y_ER) && !Match(word, 0, DANGER_RANGER_MANGER) && !Match(word, n - 1, E_I) && !Match(word, n - 1, RGY_OGY))
+                        if ((n > 2) && Match(word, n - 1, 'U') && Match(word, n - 3, C_G_L_R_T))
                         {
-                            Add("K", "J", ref sbPrimary, ref sbSecondary, ref hasAlternate);
-                            n += 2;
-                            break;
+                            Add("F", ref sbPrimary, ref sbSecondary);
                         }
-
-                        if (Match(word, n + 1, E_I_Y) || Match(word, n - 1, AGGI_OGGI))
+                        else if ((n > 0) && !Match(word, n - 1, 'I'))
                         {
-                            if (Match(word, 0, VAN__VON__SCH) || Match(word, n + 1, ET))
-                            {
-                                Add("K", ref sbPrimary, ref sbSecondary);
-                            }
-                            else
-                            {
-                                if (Match(word, n + 1, IER))
-                                    Add("J", ref sbPrimary, ref sbSecondary);
-                                else
-                                    Add("J", "K", ref sbPrimary, ref sbSecondary, ref hasAlternate);
-                            }
-                            n += 2;
-                            break;
+                            Add("K", ref sbPrimary, ref sbSecondary);
                         }
 
-                        Add("K", ref sbPrimary, ref sbSecondary);
-                        n += Match(word, n + 1, 'G') ? 2 : 1;
-                        break;
-                    case 'H':
-                        if (((n == 0) || IsVowel(word, n - 1)) && IsVowel(word, n + 1))
-                        {
-                            Add("H", ref sbPrimary, ref sbSecondary);
-                            n += 2;
-                        }
-                        else
-                        {
-                            n++;
-                        }
+                        n += 2;
                         break;
-                    case 'J':
-                        if (Match(word, n, JOSE) || Match(word, 0, SAN_))
-                        {
-                            if (((n == 0) && Match(word, n + 4, ' ')) || Match(word, 0, SAN_))
-                            {
-                                Add("H", ref sbPrimary, ref sbSecondary);
-                            }
-                            else
-                            {
-                                Add("J", "H", ref sbPrimary, ref sbSecondary, ref hasAlternate);
-                            }
-                            n++;
-                            break;
-                        }
+                    }
 
-                        if ((n == 0) && !Match(word, n, JOSE))
+                    if (Match(word, n + 1, 'N'))
+                    {
+                        if ((n == 1) && IsVowel(word, 0) && !isSlavoGermanic)
                         {
-                            Add("J", "A", ref sbPrimary, ref sbSecondary, ref hasAlternate);
+                            Add("KN", "N", ref sbPrimary, ref sbSecondary, ref hasAlternate);
                         }
                         else
                         {
-                            if (IsVowel(word, n - 1) && !isSlavoGermanic && Match(word, n + 1, A_O))
+                            if (!Match(word, n + 2, EY) && !Match(word, n + 1, 'Y') && !isSlavoGermanic)
                             {
-                                Add("J", "H", ref sbPrimary, ref sbSecondary, ref hasAlternate);
+                                Add("N", "KN", ref sbPrimary, ref sbSecondary, ref hasAlternate);
                             }
                             else
                             {
-                                if (n == last)
-                                {
-                                    Add("J", " ", ref sbPrimary, ref sbSecondary, ref hasAlternate);
-                                }
-                                else
-                                {
-                                    if (!Match(word, n + 1, L_T_K_S_N_M_B_Z) && !Match(word, n - 1, S_K_L))
-                                        Add("J", ref sbPrimary, ref sbSecondary);
-                                }
+                                Add("KN", ref sbPrimary, ref sbSecondary);
                             }
                         }
+                        n += 2;
+                        break;
+                    }
 
-                        n += Match(word, n + 1, 'J') ? 2 : 1;
+                    if (Match(word, n + 1, LI) && !isSlavoGermanic)
+                    {
+                        Add("KL", "L", ref sbPrimary, ref sbSecondary, ref hasAlternate);
+                        n += 2;
                         break;
-                    case 'K':
-                        n += Match(word, n + 1, 'K') ? 2 : 1;
-                        Add("K", ref sbPrimary, ref sbSecondary);
+                    }
+
+                    if ((n == 0) && Match(word, n + 1, Y_ES_EP_EB_EL_EY_IB_IL_IN_IE_EI_ER))
+                    {
+                        Add("K", "J", ref sbPrimary, ref sbSecondary, ref hasAlternate);
+                        n += 2;
                         break;
-                    case 'L':
-                        if (Match(word, n + 1, 'L'))
+                    }
+
+                    if (Match(word, n + 1, Y_ER) && !Match(word, 0, DANGER_RANGER_MANGER) && !Match(word, n - 1, E_I) && !Match(word, n - 1, RGY_OGY))
+                    {
+                        Add("K", "J", ref sbPrimary, ref sbSecondary, ref hasAlternate);
+                        n += 2;
+                        break;
+                    }
+
+                    if (Match(word, n + 1, E_I_Y) || Match(word, n - 1, AGGI_OGGI))
+                    {
+                        if (Match(word, 0, VAN__VON__SCH) || Match(word, n + 1, ET))
                         {
-                            if (((n == length - 3) && Match(word, n - 1, ILLO_ILLA_ALLE)) || ((Match(word, last - 1, AS_OS) || Match(word, last, A_O)) && Match(word, n - 1, ALLE)))
-                            {
-                                Add("L", " ", ref sbPrimary, ref sbSecondary, ref hasAlternate);
-                                n += 2;
-                                break;
-                            }
-                            n += 2;
+                            Add("K", ref sbPrimary, ref sbSecondary);
                         }
                         else
                         {
-                            n++;
+                            if (Match(word, n + 1, IER))
+                                Add("J", ref sbPrimary, ref sbSecondary);
+                            else
+                                Add("J", "K", ref sbPrimary, ref sbSecondary, ref hasAlternate);
                         }
-                        Add("L", ref sbPrimary, ref sbSecondary);
+                        n += 2;
                         break;
-                    case 'M':
-                        if ((Match(word, n - 1, UMB) && ((n + 1 == last) || Match(word, n + 2, ER))) || Match(word, n + 1, 'M'))
+                    }
+
+                    Add("K", ref sbPrimary, ref sbSecondary);
+                    n += Match(word, n + 1, 'G') ? 2 : 1;
+                    break;
+                case 'H':
+                    if (((n == 0) || IsVowel(word, n - 1)) && IsVowel(word, n + 1))
+                    {
+                        Add("H", ref sbPrimary, ref sbSecondary);
+                        n += 2;
+                    }
+                    else
+                    {
+                        n++;
+                    }
+                    break;
+                case 'J':
+                    if (Match(word, n, JOSE) || Match(word, 0, SAN_))
+                    {
+                        if (((n == 0) && Match(word, n + 4, ' ')) || Match(word, 0, SAN_))
                         {
-                            n += 2;
+                            Add("H", ref sbPrimary, ref sbSecondary);
                         }
                         else
                         {
-                            n++;
+                            Add("J", "H", ref sbPrimary, ref sbSecondary, ref hasAlternate);
                         }
-                        Add("M", ref sbPrimary, ref sbSecondary);
-                        break;
-                    case 'N':
-                        n += Match(word, n + 1, 'N') ? 2 : 1;
-                        Add("N", ref sbPrimary, ref sbSecondary);
-                        break;
-                    case 'Ñ':
                         n++;
-                        Add("N", ref sbPrimary, ref sbSecondary);
                         break;
-                    case 'P':
-                        if (Match(word, n + 1, 'H'))
-                        {
-                            Add("F", ref sbPrimary, ref sbSecondary);
-                            n += 2;
-                            break;
-                        }
+                    }
 
-                        n += Match(word, n + 1, P_B) ? 2 : 1;
-                        Add("P", ref sbPrimary, ref sbSecondary);
-                        break;
-                    case 'Q':
-                        n += Match(word, n + 1, 'Q') ? 2 : 1;
-                        Add("K", ref sbPrimary, ref sbSecondary);
-                        break;
-                    case 'R':
-                        if ((n == last) && !isSlavoGermanic && Match(word, n - 2, IE) && !Match(word, n - 4, ME_MA))
+                    if ((n == 0) && !Match(word, n, JOSE))
+                    {
+                        Add("J", "A", ref sbPrimary, ref sbSecondary, ref hasAlternate);
+                    }
+                    else
+                    {
+                        if (IsVowel(word, n - 1) && !isSlavoGermanic && Match(word, n + 1, A_O))
                         {
-                            Add("", "R", ref sbPrimary, ref sbSecondary, ref hasAlternate);
+                            Add("J", "H", ref sbPrimary, ref sbSecondary, ref hasAlternate);
                         }
                         else
                         {
-                            Add("R", ref sbPrimary, ref sbSecondary);
-                        }
-
-                        n += Match(word, n + 1, 'R') ? 2 : 1;
-                        break;
-                    case 'S':
-                        if (Match(word, n - 1, ISL_YSL))
-                        {
-                            n++;
-                            break;
-                        }
-
-                        if ((n == 0) && Match(word, n, SUGAR))
-                        {
-                            Add("X", "S", ref sbPrimary, ref sbSecondary, ref hasAlternate);
-                            n++;
-                            break;
+                            if (n == last)
+                            {
+                                Add("J", " ", ref sbPrimary, ref sbSecondary, ref hasAlternate);
+                            }
+                            else
+                            {
+                                if (!Match(word, n + 1, L_T_K_S_N_M_B_Z) && !Match(word, n - 1, S_K_L))
+                                    Add("J", ref sbPrimary, ref sbSecondary);
+                            }
                         }
+                    }
 
-                        if (Match(word, n, SH))
+                    n += Match(word, n + 1, 'J') ? 2 : 1;
+                    break;
+                case 'K':
+                    n += Match(word, n + 1, 'K') ? 2 : 1;
+                    Add("K", ref sbPrimary, ref sbSecondary);
+                    break;
+                case 'L':
+                    if (Match(word, n + 1, 'L'))
+                    {
+                        if (((n == length - 3) && Match(word, n - 1, ILLO_ILLA_ALLE)) || ((Match(word, last - 1, AS_OS) || Match(word, last, A_O)) && Match(word, n - 1, ALLE)))
                         {
-                            Add(Match(word, n + 1, HEIM_HOEK_HOLM_HOLZ) ? "S" : "X", ref sbPrimary, ref sbSecondary);
+                            Add("L", " ", ref sbPrimary, ref sbSecondary, ref hasAlternate);
                             n += 2;
                             break;
                         }
+                        n += 2;
+                    }
+                    else
+                    {
+                        n++;
+                    }
+                    Add("L", ref sbPrimary, ref sbSecondary);
+                    break;
+                case 'M':
+                    if ((Match(word, n - 1, UMB) && ((n + 1 == last) || Match(word, n + 2, ER))) || Match(word, n + 1, 'M'))
+                    {
+                        n += 2;
+                    }
+                    else
+                    {
+                        n++;
+                    }
+                    Add("M", ref sbPrimary, ref sbSecondary);
+                    break;
+                case 'N':
+                    n += Match(word, n + 1, 'N') ? 2 : 1;
+                    Add("N", ref sbPrimary, ref sbSecondary);
+                    break;
+                case 'Ñ':
+                    n++;
+                    Add("N", ref sbPrimary, ref sbSecondary);
+                    break;
+                case 'P':
+                    if (Match(word, n + 1, 'H'))
+                    {
+                        Add("F", ref sbPrimary, ref sbSecondary);
+                        n += 2;
+                        break;
+                    }
+
+                    n += Match(word, n + 1, P_B) ? 2 : 1;
+                    Add("P", ref sbPrimary, ref sbSecondary);
+                    break;
+                case 'Q':
+                    n += Match(word, n + 1, 'Q') ? 2 : 1;
+                    Add("K", ref sbPrimary, ref sbSecondary);
+                    break;
+                case 'R':
+                    if ((n == last) && !isSlavoGermanic && Match(word, n - 2, IE) && !Match(word, n - 4, ME_MA))
+                    {
+                        Add("", "R", ref sbPrimary, ref sbSecondary, ref hasAlternate);
+                    }
+                    else
+                    {
+                        Add("R", ref sbPrimary, ref sbSecondary);
+                    }
+
+                    n += Match(word, n + 1, 'R') ? 2 : 1;
+                    break;
+                case 'S':
+                    if (Match(word, n - 1, ISL_YSL))
+                    {
+                        n++;
+                        break;
+                    }
 
-                        if (Match(word, n, SIO_SIA) || Match(word, n, SIAN))
-                        {
-                            if (!isSlavoGermanic)
-                                Add("S", "X", ref sbPrimary, ref sbSecondary, ref hasAlternate);
-                            else
-                                Add("S", ref sbPrimary, ref sbSecondary);
-                            n += 3;
-                            break;
-                        }
+                    if ((n == 0) && Match(word, n, SUGAR))
+                    {
+                        Add("X", "S", ref sbPrimary, ref sbSecondary, ref hasAlternate);
+                        n++;
+                        break;
+                    }
 
-                        if (((n == 0) && Match(word, n + 1, M_N_L_W)) || Match(word, n + 1, 'Z'))
-                        {
+                    if (Match(word, n, SH))
+                    {
+                        Add(Match(word, n + 1, HEIM_HOEK_HOLM_HOLZ) ? "S" : "X", ref sbPrimary, ref sbSecondary);
+                        n += 2;
+                        break;
+                    }
+
+                    if (Match(word, n, SIO_SIA) || Match(word, n, SIAN))
+                    {
+                        if (!isSlavoGermanic)
                             Add("S", "X", ref sbPrimary, ref sbSecondary, ref hasAlternate);
-                            n += Match(word, n + 1, 'Z') ? 2 : 1;
-                            break;
-                        }
+                        else
+                            Add("S", ref sbPrimary, ref sbSecondary);
+                        n += 3;
+                        break;
+                    }
+
+                    if (((n == 0) && Match(word, n + 1, M_N_L_W)) || Match(word, n + 1, 'Z'))
+                    {
+                        Add("S", "X", ref sbPrimary, ref sbSecondary, ref hasAlternate);
+                        n += Match(word, n + 1, 'Z') ? 2 : 1;
+                        break;
+                    }
 
-                        if (Match(word, n, SC))
+                    if (Match(word, n, SC))
+                    {
+                        if (Match(word, n + 2, 'H'))
                         {
-                            if (Match(word, n + 2, 'H'))
+                            if (Match(word, n + 3, OO_ER_EN_UY_ED_EM))
                             {
-                                if (Match(word, n + 3, OO_ER_EN_UY_ED_EM))
-                                {
-                                    if (Match(word, n + 3, ER_EN))
-                                        Add("X", "SK", ref sbPrimary, ref sbSecondary, ref hasAlternate);
-                                    else
-                                        Add("SK", ref sbPrimary, ref sbSecondary);
-                                    n += 3;
-                                    break;
-                                }
-                                if ((n == 0) && !IsVowel(word, 3) && !Match(word, 3, 'W'))
-                                    Add("X", "S", ref sbPrimary, ref sbSecondary, ref hasAlternate);
+                                if (Match(word, n + 3, ER_EN))
+                                    Add("X", "SK", ref sbPrimary, ref sbSecondary, ref hasAlternate);
                                 else
-                                    Add("X", ref sbPrimary, ref sbSecondary);
+                                    Add("SK", ref sbPrimary, ref sbSecondary);
                                 n += 3;
                                 break;
                             }
-
-                            Add(Match(word, n + 2, I_E_Y) ? "S" : "SK", ref sbPrimary, ref sbSecondary);
+                            if ((n == 0) && !IsVowel(word, 3) && !Match(word, 3, 'W'))
+                                Add("X", "S", ref sbPrimary, ref sbSecondary, ref hasAlternate);
+                            else
+                                Add("X", ref sbPrimary, ref sbSecondary);
                             n += 3;
                             break;
                         }
 
-                        if ((n == last) && Match(word, n - 2, AI_OI))
-                            Add("", "S", ref sbPrimary, ref sbSecondary, ref hasAlternate);
-                        else
-                            Add("S", ref sbPrimary, ref sbSecondary);
-
-                        n += Match(word, n + 1, S_Z) ? 2 : 1;
+                        Add(Match(word, n + 2, I_E_Y) ? "S" : "SK", ref sbPrimary, ref sbSecondary);
+                        n += 3;
                         break;
-                    case 'T':
-                        if (Match(word, n, TION))
-                        {
-                            Add("X", ref sbPrimary, ref sbSecondary);
-                            n += 3;
-                            break;
-                        }
-
-                        if (Match(word, n, TIA_TCH))
-                        {
-                            Add("X", ref sbPrimary, ref sbSecondary);
-                            n += 3;
-                            break;
-                        }
+                    }
 
-                        if (Match(word, n, TH_TTH))
-                        {
-                            if (Match(word, n + 2, OM_AM) || Match(word, 0, VAN__VON__SCH))
-                                Add("T", ref sbPrimary, ref sbSecondary);
-                            else
-                                Add("0", "T", ref sbPrimary, ref sbSecondary, ref hasAlternate);
-                            n += 2;
-                            break;
-                        }
+                    if ((n == last) && Match(word, n - 2, AI_OI))
+                        Add("", "S", ref sbPrimary, ref sbSecondary, ref hasAlternate);
+                    else
+                        Add("S", ref sbPrimary, ref sbSecondary);
 
-                        n += Match(word, n + 1, T_D) ? 2 : 1;
-                        Add("T", ref sbPrimary, ref sbSecondary);
-                        break;
-                    case 'V':
-                        n += Match(word, n + 1, 'V') ? 2 : 1;
-                        Add("F", ref sbPrimary, ref sbSecondary);
+                    n += Match(word, n + 1, S_Z) ? 2 : 1;
+                    break;
+                case 'T':
+                    if (Match(word, n, TION))
+                    {
+                        Add("X", ref sbPrimary, ref sbSecondary);
+                        n += 3;
                         break;
-                    case 'W':
-                        if (Match(word, n, WR))
-                        {
-                            Add("R", ref sbPrimary, ref sbSecondary);
-                            n += 2;
-                            break;
-                        }
+                    }
 
-                        if ((n == 0) && (IsVowel(word, n + 1) || Match(word, n, WH)))
-                        {
-                            if (IsVowel(word, n + 1))
-                                Add("A", "F", ref sbPrimary, ref sbSecondary, ref hasAlternate);
-                            else
-                                Add("A", ref sbPrimary, ref sbSecondary);
-                        }
+                    if (Match(word, n, TIA_TCH))
+                    {
+                        Add("X", ref sbPrimary, ref sbSecondary);
+                        n += 3;
+                        break;
+                    }
 
-                        if (((n == last) && IsVowel(word, n - 1)) || Match(word, n - 1, EWSKI_EWSKY_OWSKI_OWSKY) || Match(word, 0, SCH))
-                        {
-                            Add("", "F", ref sbPrimary, ref sbSecondary, ref hasAlternate);
-                            n++;
-                            break;
-                        }
+                    if (Match(word, n, TH_TTH))
+                    {
+                        if (Match(word, n + 2, OM_AM) || Match(word, 0, VAN__VON__SCH))
+                            Add("T", ref sbPrimary, ref sbSecondary);
+                        else
+                            Add("0", "T", ref sbPrimary, ref sbSecondary, ref hasAlternate);
+                        n += 2;
+                        break;
+                    }
+
+                    n += Match(word, n + 1, T_D) ? 2 : 1;
+                    Add("T", ref sbPrimary, ref sbSecondary);
+                    break;
+                case 'V':
+                    n += Match(word, n + 1, 'V') ? 2 : 1;
+                    Add("F", ref sbPrimary, ref sbSecondary);
+                    break;
+                case 'W':
+                    if (Match(word, n, WR))
+                    {
+                        Add("R", ref sbPrimary, ref sbSecondary);
+                        n += 2;
+                        break;
+                    }
 
-                        if (Match(word, n, WICZ_WITZ))
-                        {
-                            Add("TS", "FX", ref sbPrimary, ref sbSecondary, ref hasAlternate);
-                            n += 4;
-                            break;
-                        }
+                    if ((n == 0) && (IsVowel(word, n + 1) || Match(word, n, WH)))
+                    {
+                        if (IsVowel(word, n + 1))
+                            Add("A", "F", ref sbPrimary, ref sbSecondary, ref hasAlternate);
+                        else
+                            Add("A", ref sbPrimary, ref sbSecondary);
+                    }
 
+                    if (((n == last) && IsVowel(word, n - 1)) || Match(word, n - 1, EWSKI_EWSKY_OWSKI_OWSKY) || Match(word, 0, SCH))
+                    {
+                        Add("", "F", ref sbPrimary, ref sbSecondary, ref hasAlternate);
                         n++;
                         break;
-                    case 'X':
-                        if (!((n == last) && (Match(word, n - 3, IAU_EAU) || Match(word, n - 2, AU_OU))))
-                            Add("KS", ref sbPrimary, ref sbSecondary);
+                    }
 
-                        n += Match(word, n + 1, C_X) ? 2 : 1;
+                    if (Match(word, n, WICZ_WITZ))
+                    {
+                        Add("TS", "FX", ref sbPrimary, ref sbSecondary, ref hasAlternate);
+                        n += 4;
                         break;
-                    case 'Z':
-                        if (Match(word, n + 1, 'H'))
-                        {
-                            Add("J", ref sbPrimary, ref sbSecondary);
-                            n += 2;
-                            break;
-                        }
-                        if (Match(word, n + 1, ZO_ZI_ZA) || (isSlavoGermanic && (n > 0) && !Match(word, n - 1, 'T')))
-                        {
-                            Add("S", "TS", ref sbPrimary, ref sbSecondary, ref hasAlternate);
-                        }
-                        else
-                        {
-                            Add("S", ref sbPrimary, ref sbSecondary);
-                        }
-
-                        n += Match(word, n + 1, 'Z') ? 2 : 1;
-                        break;
-                    default:
-                        n++;
+                    }
+
+                    n++;
+                    break;
+                case 'X':
+                    if (!((n == last) && (Match(word, n - 3, IAU_EAU) || Match(word, n - 2, AU_OU))))
+                        Add("KS", ref sbPrimary, ref sbSecondary);
+
+                    n += Match(word, n + 1, C_X) ? 2 : 1;
+                    break;
+                case 'Z':
+                    if (Match(word, n + 1, 'H'))
+                    {
+                        Add("J", ref sbPrimary, ref sbSecondary);
+                        n += 2;
                         break;
-                }
-            }
+                    }
+                    if (Match(word, n + 1, ZO_ZI_ZA) || (isSlavoGermanic && (n > 0) && !Match(word, n - 1, 'T')))
+                    {
+                        Add("S", "TS", ref sbPrimary, ref sbSecondary, ref hasAlternate);
+                    }
+                    else
+                    {
+                        Add("S", ref sbPrimary, ref sbSecondary);
+                    }
 
-            if (MaxLength < 0)
-            {
-                if (hasAlternate)
-                    return new[] { sbPrimary.ToString(), sbSecondary.ToString() };
-                return new[] { sbPrimary.ToString() };
-            }
-            int primaryLength = Math.Min(MaxLength, sbPrimary.Length);
-            if (hasAlternate)
-            {
-                int secondaryLength = Math.Min(MaxLength, sbSecondary.Length);
-                return new[] { sbPrimary.ToString().Substring(0, primaryLength - 0), sbSecondary.ToString().Substring(0, secondaryLength - 0) };
+                    n += Match(word, n + 1, 'Z') ? 2 : 1;
+                    break;
+                default:
+                    n++;
+                    break;
             }
-            return new[] { sbPrimary.ToString().Substring(0, primaryLength - 0) };
         }
 
-        public static IEnumerable<string> GetKeys(string phrase)
+        if (MaxLength < 0)
         {
-            var set = new HashSet<string>();
-            var keys = new List<string>();
+            if (hasAlternate)
+                return new[] { sbPrimary.ToString(), sbSecondary.ToString() };
+            return new[] { sbPrimary.ToString() };
+        }
+        int primaryLength = Math.Min(MaxLength, sbPrimary.Length);
+        if (hasAlternate)
+        {
+            int secondaryLength = Math.Min(MaxLength, sbSecondary.Length);
+            return new[] { sbPrimary.ToString().Substring(0, primaryLength - 0), sbSecondary.ToString().Substring(0, secondaryLength - 0) };
+        }
+        return new[] { sbPrimary.ToString().Substring(0, primaryLength - 0) };
+    }
 
-            foreach (Match m in regex.Matches(phrase))
-            {
-                if (m.Value.Length > 2) set.Add(m.Value);
-            }
+    public static IEnumerable<string> GetKeys(string phrase)
+    {
+        var set = new HashSet<string>();
+        var keys = new List<string>();
+
+        foreach (Match m in regex.Matches(phrase))
+        {
+            if (m.Value.Length > 2) set.Add(m.Value);
+        }
 
-            if (set.Count == 0) return keys;
+        if (set.Count == 0) return keys;
 
-            foreach (var word in set)
+        foreach (var word in set)
+        {
+            foreach (var key in BuildKeys(word))
             {
-                foreach (var key in BuildKeys(word))
-                {
-                    keys.Add(key);
-                }
+                keys.Add(key);
             }
-
-            return keys;
         }
+
+        return keys;
     }
 }
diff --git a/MongoDB.Entities/Core/Entity.cs b/MongoDB.Entities/Core/Entity.cs
index 614e646fc..921dddd8f 100644
--- a/MongoDB.Entities/Core/Entity.cs
+++ b/MongoDB.Entities/Core/Entity.cs
@@ -1,23 +1,37 @@
-using MongoDB.Bson;
-using MongoDB.Bson.Serialization.Attributes;
+namespace MongoDB.Entities;
 
-namespace MongoDB.Entities
+/// <summary>
+/// Inherit this class for all entities you want to store in their own collection.
+/// </summary>
+public abstract class Entity : IEntity
 {
     /// <summary>
-    /// Inherit this class for all entities you want to store in their own collection.
+    /// This property is auto managed. A new ID will be assigned for new entities upon saving.
     /// </summary>
-    public abstract class Entity : IEntity
-    {
-        /// <summary>
-        /// This property is auto managed. A new ID will be assigned for new entities upon saving.
-        /// </summary>
-        [BsonId, AsObjectId]
-        public string? ID { get; set; }
+    [BsonId, AsObjectId]
+    public string? ID { get; set; }
 
-        /// <summary>
-        /// Override this method in order to control the generation of IDs for new entities.
-        /// </summary>
-        public virtual string GenerateNewID()
-            => ObjectId.GenerateNewId().ToString();
-    }
+    /// <summary>
+    /// Override this method in order to control the generation of IDs for new entities.
+    /// </summary>
+    public virtual string GenerateNewID()
+        => ObjectId.GenerateNewId().ToString();
 }
+
+/// <summary>
+/// Inherit this class for all entities you want to store in their own collection.
+/// </summary>
+public abstract class Entity<TId> : IEntity<TId>
+    where TId : IComparable<TId>, IEquatable<TId>
+{
+    /// <summary>
+    /// This property is auto managed. A new ID will be assigned for new entities upon saving.
+    /// </summary>
+    [BsonId]
+    public TId? ID { get; set; }
+
+    /// <summary>
+    /// Override this method in order to control the generation of IDs for new entities.
+    /// </summary>
+    public abstract TId GenerateNewID();
+}
\ No newline at end of file
diff --git a/MongoDB.Entities/Core/EntityCache.cs b/MongoDB.Entities/Core/EntityCache.cs
index 0fc9c30a3..d230f4f2b 100644
--- a/MongoDB.Entities/Core/EntityCache.cs
+++ b/MongoDB.Entities/Core/EntityCache.cs
@@ -1,122 +1,122 @@
-using MongoDB.Bson.Serialization;
-using MongoDB.Bson.Serialization.Attributes;
-using MongoDB.Driver;
-using MongoDB.Driver.Linq;
-using System;
-using System.Collections.Concurrent;
-using System.Collections.Generic;
-using System.Linq;
-using System.Reflection;
-#nullable enable
-namespace MongoDB.Entities
+using System.Collections.Concurrent;
+
+namespace MongoDB.Entities;
+
+internal class Cache
 {
-    internal abstract class Cache
+    protected PropertyInfo[] _updatableProps = null!;
+
+    public bool HasCreatedOn { get; protected set; }
+    public bool HasModifiedOn { get; protected set; }
+    public string ModifiedOnPropName { get; } = nameof(IModifiedOn.ModifiedOn);
+    public PropertyInfo? ModifiedByProp { get; protected set; }
+    public bool HasIgnoreIfDefaultProps { get; protected set; }
+    public string CollectionName { get; protected set; } = null!;
+    public bool IsFileEntity { get; protected set; }
+    protected Cache(Type type)
     {
-        protected PropertyInfo[] _updatableProps = null!;
-
-        public bool HasCreatedOn { get; protected set; }
-        public bool HasModifiedOn { get; protected set; }
-        public string ModifiedOnPropName { get; } = nameof(IModifiedOn.ModifiedOn);
-        public PropertyInfo? ModifiedByProp { get; protected set; }
-        public bool HasIgnoreIfDefaultProps { get; protected set; }
-        public string CollectionName { get; protected set; } = null!;
-        public bool IsFileEntity { get; protected set; }
-    }
+        var interfaces = type.GetInterfaces();
 
-    internal class EntityCache<T> : Cache where T : IEntity
-    {
-        
+        var collAttrb = type.GetCustomAttribute<CollectionAttribute>(false);
 
-        public ConcurrentDictionary<string, Watcher<T>> Watchers { get; } = new();
+        CollectionName = collAttrb != null ? collAttrb.Name : type.Name;
 
-        private ProjectionDefinition<T>? _requiredPropsProjection;
+        if (string.IsNullOrWhiteSpace(CollectionName) || CollectionName.Contains("~"))
+            throw new ArgumentException($"{CollectionName} is an illegal name for a collection!");
 
-        public EntityCache()
-        {
-            var type = typeof(T);
-            var interfaces = type.GetInterfaces();
 
-            var collAttrb = type.GetCustomAttribute<CollectionAttribute>(false);
+        HasCreatedOn = interfaces.Any(i => i == typeof(ICreatedOn));
+        HasModifiedOn = interfaces.Any(i => i == typeof(IModifiedOn));
+        IsFileEntity = typeof(FileEntity).IsAssignableFrom(type.BaseType);
 
-            CollectionName = collAttrb != null ? collAttrb.Name : type.Name;
+        _updatableProps = type.GetProperties()
+            .Where(p =>
+                   p.PropertyType.Name != ManyBase.PropTypeName &&
+                  !p.IsDefined(typeof(BsonIdAttribute), false) &&
+                  !p.IsDefined(typeof(BsonIgnoreAttribute), false))
+            .ToArray();
 
-            if (string.IsNullOrWhiteSpace(CollectionName) || CollectionName.Contains("~"))
-                throw new ArgumentException($"{CollectionName} is an illegal name for a collection!");
+        HasIgnoreIfDefaultProps = _updatableProps.Any(p =>
+              p.IsDefined(typeof(BsonIgnoreIfDefaultAttribute), false) ||
+              p.IsDefined(typeof(BsonIgnoreIfNullAttribute), false));
 
+        try
+        {
+            ModifiedByProp = _updatableProps.SingleOrDefault(p => typeof(ModifiedBy).IsAssignableFrom(p.PropertyType));
+        }
+        catch (InvalidOperationException)
+        {
+            throw new InvalidOperationException("Multiple [ModifiedBy] properties are not allowed on entities!");
+        }
+    }
 
-            HasCreatedOn = interfaces.Any(i => i == typeof(ICreatedOn));
-            HasModifiedOn = interfaces.Any(i => i == typeof(IModifiedOn));
-            IsFileEntity = typeof(FileEntity).IsAssignableFrom(type.BaseType);
 
-            _updatableProps = type.GetProperties()
-                .Where(p =>
-                       p.PropertyType.Name != ManyBase.PropTypeName &&
-                      !p.IsDefined(typeof(BsonIdAttribute), false) &&
-                      !p.IsDefined(typeof(BsonIgnoreAttribute), false))
-                .ToArray();
 
-            HasIgnoreIfDefaultProps = _updatableProps.Any(p =>
-                    p.IsDefined(typeof(BsonIgnoreIfDefaultAttribute), false) ||
-                    p.IsDefined(typeof(BsonIgnoreIfNullAttribute), false));
 
-            try
-            {
-                ModifiedByProp = _updatableProps.SingleOrDefault(p => typeof(ModifiedBy).IsAssignableFrom(p.PropertyType));
-            }
-            catch (InvalidOperationException)
-            {
-                throw new InvalidOperationException("Multiple [ModifiedBy] properties are not allowed on entities!");
-            }
-        }
+}
 
-        public IEnumerable<PropertyInfo> UpdatableProps(T entity)
+internal class EntityCache<T> : Cache
+{
+    public ConcurrentDictionary<string, Watcher<T>> Watchers { get; } = new();
+
+    private static EntityCache<T>? _default;
+    public static EntityCache<T> Default => _default ??= new();
+
+    private EntityCache() : base(typeof(T))
+    {
+    }
+
+    public IEnumerable<PropertyInfo> UpdatableProps(T entity)
+    {
+        if (HasIgnoreIfDefaultProps)
         {
-            if (HasIgnoreIfDefaultProps)
-            {
-                return _updatableProps.Where(p =>
-                    !(p.IsDefined(typeof(BsonIgnoreIfDefaultAttribute), false) && p.GetValue(entity) == default) &&
-                    !(p.IsDefined(typeof(BsonIgnoreIfNullAttribute), false) && p.GetValue(entity) == null));
-            }
-            return _updatableProps;
+            return _updatableProps.Where(p =>
+                !(p.IsDefined(typeof(BsonIgnoreIfDefaultAttribute), false) && p.GetValue(entity) == default) &&
+                !(p.IsDefined(typeof(BsonIgnoreIfNullAttribute), false) && p.GetValue(entity) == null));
         }
+        return _updatableProps;
+    }
 
-        public ProjectionDefinition<T, TProjection> CombineWithRequiredProps<TProjection>(ProjectionDefinition<T, TProjection> userProjection)
-        {
-            if (userProjection == null)
-                throw new InvalidOperationException("Please use .Project() method before .IncludeRequiredProps()");
+    private ProjectionDefinition<T>? _requiredPropsProjection;
 
-            if (_requiredPropsProjection is null)
-            {
-                _requiredPropsProjection = "{_id:1}";
+    public ProjectionDefinition<T, TProjection> CombineWithRequiredProps<TProjection>(ProjectionDefinition<T, TProjection> userProjection)
+    {
+        if (userProjection == null)
+            throw new InvalidOperationException("Please use .Project() method before .IncludeRequiredProps()");
 
-                var props = typeof(T)
-                    .GetProperties()
-                    .Where(p => p.IsDefined(typeof(BsonRequiredAttribute), false));
+        if (_requiredPropsProjection is null)
+        {
+            _requiredPropsProjection = "{_id:1}";
+
+            var props = typeof(T)
+                .GetProperties()
+                .Where(p => p.IsDefined(typeof(BsonRequiredAttribute), false));
 
-                if (!props.Any())
-                    throw new InvalidOperationException("Unable to find any entity properties marked with [BsonRequired] attribute!");
+            if (!props.Any())
+                throw new InvalidOperationException("Unable to find any entity properties marked with [BsonRequired] attribute!");
 
-                FieldAttribute attr;
-                foreach (var p in props)
-                {
-                    attr = p.GetCustomAttribute<FieldAttribute>();
+            FieldAttribute attr;
+            foreach (var p in props)
+            {
+                attr = p.GetCustomAttribute<FieldAttribute>();
 
-                    if (attr is null)
-                        _requiredPropsProjection = _requiredPropsProjection.Include(p.Name);
-                    else
-                        _requiredPropsProjection = _requiredPropsProjection.Include(attr.ElementName);
-                }
+                if (attr is null)
+                    _requiredPropsProjection = _requiredPropsProjection.Include(p.Name);
+                else
+                    _requiredPropsProjection = _requiredPropsProjection.Include(attr.ElementName);
             }
+        }
 
-            ProjectionDefinition<T> userProj = userProjection.Render(
-                BsonSerializer.LookupSerializer<T>(),
-                BsonSerializer.SerializerRegistry).Document;
+        ProjectionDefinition<T> userProj = userProjection.Render(
+            BsonSerializer.LookupSerializer<T>(),
+            BsonSerializer.SerializerRegistry).Document;
 
-            return Builders<T>.Projection.Combine(new[]
-            {
+        return Builders<T>.Projection.Combine(new[]
+        {
                 _requiredPropsProjection,
                 userProj
             });
-        }
     }
-}
\ No newline at end of file
+
+
+}
diff --git a/MongoDB.Entities/Core/FileEntity.cs b/MongoDB.Entities/Core/FileEntity.cs
index 97a2349c2..6ab699647 100644
--- a/MongoDB.Entities/Core/FileEntity.cs
+++ b/MongoDB.Entities/Core/FileEntity.cs
@@ -1,281 +1,284 @@
-using MongoDB.Bson;
-using MongoDB.Bson.Serialization.Attributes;
-using MongoDB.Driver;
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Runtime.CompilerServices;
+using System.Runtime.CompilerServices;
 using System.Security.Cryptography;
-using System.Threading;
-using System.Threading.Tasks;
 
 [assembly: InternalsVisibleTo("MongoDB.Entities.Tests")]
-namespace MongoDB.Entities
+namespace MongoDB.Entities;
+
+public class FileEntity : FileEntity<string>
 {
-    /// <summary>
-    /// Inherit this base class in order to create your own File Entities
-    /// </summary>
-    public abstract class FileEntity : Entity
+    public override string GenerateNewID()
     {
-        /// <summary>
-        /// The total amount of data in bytes that has been uploaded so far
-        /// </summary>
-        [BsonElement]
-        public long FileSize { get; internal set; }
-
-        /// <summary>
-        /// The number of chunks that have been created so far
-        /// </summary>
-        [BsonElement]
-        public int ChunkCount { get; internal set; }
-
-        /// <summary>
-        /// Returns true only when all the chunks have been stored successfully in mongodb
-        /// </summary>
-        [BsonElement]
-        public bool UploadSuccessful { get; internal set; }
-
-        /// <summary>
-        /// If this value is set, the uploaded data will be hashed and matched against this value. If the hash is not equal, an exception will be thrown by the UploadAsync() method.
-        /// </summary>
-        [IgnoreDefault]
-        public string? MD5 { get; set; }
+        return ObjectId.GenerateNewId().ToString();
     }
+}
+/// <summary>
+/// Inherit this base class in order to create your own File Entities
+/// </summary>
+[Collection("[BINARY_CHUNKS]")]
+public abstract class FileEntity<TId> : Entity<TId>
+    where TId : IComparable<TId>, IEquatable<TId>
+{
+    /// <summary>
+    /// The total amount of data in bytes that has been uploaded so far
+    /// </summary>
+    [BsonElement]
+    public long FileSize { get; internal set; }
 
-    [Collection("[BINARY_CHUNKS]")]
-    internal class FileChunk : IEntity
-    {
-        [BsonId, ObjectId]
-        public string ID { get; set; } = null!;
+    /// <summary>
+    /// The number of chunks that have been created so far
+    /// </summary>
+    [BsonElement]
+    public int ChunkCount { get; internal set; }
+
+    /// <summary>
+    /// Returns true only when all the chunks have been stored successfully in mongodb
+    /// </summary>
+    [BsonElement]
+    public bool UploadSuccessful { get; internal set; }
+
+    /// <summary>
+    /// If this value is set, the uploaded data will be hashed and matched against this value. If the hash is not equal, an exception will be thrown by the UploadAsync() method.
+    /// </summary>
+    [IgnoreDefault]
+    public string? MD5 { get; set; }
+}
+
+[Collection("[BINARY_CHUNKS]")]
+internal class FileChunk<TFileId> : IEntity<ObjectId>
+    where TFileId : IComparable<TFileId>, IEquatable<TFileId>
+{
+    [BsonId]
+    public ObjectId ID { get; set; }
+
+    public TFileId? FileID { get; set; }
 
-        [AsObjectId]
-        public string FileID { get; set; } = null!;
+    public byte[] Data { get; set; } = Array.Empty<byte>();
 
-        public byte[] Data { get; set; } = Array.Empty<byte>();
+    public ObjectId GenerateNewID()
+        => ObjectId.GenerateNewId();
+}
 
-        public string GenerateNewID()
-            => ObjectId.GenerateNewId().ToString();
+/// <summary>
+/// Provides the interface for uploading and downloading data chunks for file entities.
+/// </summary>
+public class DataStreamer<T, TId>
+    where T : FileEntity<TId>
+    where TId : IComparable<TId>, IEquatable<TId>
+{
+    private static readonly HashSet<string> _indexedDBs = new();
+
+    private readonly T _parent;
+    private readonly DBContext _db;
+    private readonly IMongoCollection<T> _collection;
+    private readonly IMongoCollection<FileChunk<TId>> _chunkCollection;
+    private FileChunk<TId>? _doc;
+    private int _chunkSize, _readCount;
+    private byte[]? _buffer;
+    private List<byte>? _dataChunk;
+    private MD5? _md5;
+
+    internal DataStreamer(T parent, DBContext db, IMongoCollection<T> collection)
+    {
+        _parent = parent;
+        _db = db;
+        _chunkCollection = db.Collection<FileChunk<TId>>();
+        _collection = collection;
+        if (_indexedDBs.Add(db.DatabaseNamespace.DatabaseName))
+        {
+            _ = _chunkCollection.Indexes.CreateOneAsync(
+                new CreateIndexModel<FileChunk<TId>>(
+                    Builders<FileChunk<TId>>.IndexKeys.Ascending(c => c.FileID),
+                    new CreateIndexOptions { Background = true, Name = $"{nameof(FileChunk<TId>.FileID)}(Asc)" }));
+        }
     }
 
     /// <summary>
-    /// Provides the interface for uploading and downloading data chunks for file entities.
+    /// Download binary data for this file entity from mongodb in chunks into a given stream with a timeout period.
     /// </summary>
-    public class DataStreamer<T> where T : FileEntity
+    /// <param name="stream">The output stream to write the data</param>
+    /// <param name="timeOutSeconds">The maximum number of seconds allowed for the operation to complete</param>
+    /// <param name="batchSize"></param>
+    public Task DownloadWithTimeoutAsync(Stream stream, int timeOutSeconds, int batchSize = 1)
     {
-        private static readonly HashSet<string> _indexedDBs = new();
-
-        private readonly T _parent;
-        private readonly DBContext _db;
-        private readonly IMongoCollection<T> _collection;
-        private readonly IMongoCollection<FileChunk> _chunkCollection;
-        private FileChunk? _doc;
-        private int _chunkSize, _readCount;
-        private byte[]? _buffer;
-        private List<byte>? _dataChunk;
-        private MD5? _md5;
-
-        internal DataStreamer(T parent, DBContext db, IMongoCollection<T> collection)
-        {
-            _parent = parent;
-            _db = db;
-            _chunkCollection = db.Collection<FileChunk>();
-            _collection = collection;
-            if (_indexedDBs.Add(db.DatabaseNamespace.DatabaseName))
-            {
-                _ = _chunkCollection.Indexes.CreateOneAsync(
-                    new CreateIndexModel<FileChunk>(
-                        Builders<FileChunk>.IndexKeys.Ascending(c => c.FileID),
-                        new CreateIndexOptions { Background = true, Name = $"{nameof(FileChunk.FileID)}(Asc)" }));
-            }
-        }
+        return DownloadAsync(stream, batchSize, new CancellationTokenSource(timeOutSeconds * 1000).Token);
+    }
 
-        /// <summary>
-        /// Download binary data for this file entity from mongodb in chunks into a given stream with a timeout period.
-        /// </summary>
-        /// <param name="stream">The output stream to write the data</param>
-        /// <param name="timeOutSeconds">The maximum number of seconds allowed for the operation to complete</param>
-        /// <param name="batchSize"></param>
-        public Task DownloadWithTimeoutAsync(Stream stream, int timeOutSeconds, int batchSize = 1)
-        {
-            return DownloadAsync(stream, batchSize, new CancellationTokenSource(timeOutSeconds * 1000).Token);
-        }
+    /// <summary>
+    /// Download binary data for this file entity from mongodb in chunks into a given stream.
+    /// </summary>
+    /// <param name="stream">The output stream to write the data</param>
+    /// <param name="batchSize">The number of chunks you want returned at once</param>
+    /// <param name="cancellation">An optional cancellation token.</param>
+    public async Task DownloadAsync(Stream stream, int batchSize = 1, CancellationToken cancellation = default)
+    {
+        _parent.ThrowIfUnsaved();
+        if (!_parent.UploadSuccessful) throw new InvalidOperationException("Data for this file hasn't been uploaded successfully (yet)!");
+        if (!stream.CanWrite) throw new NotSupportedException("The supplied stream is not writable!");
 
-        /// <summary>
-        /// Download binary data for this file entity from mongodb in chunks into a given stream.
-        /// </summary>
-        /// <param name="stream">The output stream to write the data</param>
-        /// <param name="batchSize">The number of chunks you want returned at once</param>
-        /// <param name="cancellation">An optional cancellation token.</param>
-        public async Task DownloadAsync(Stream stream, int batchSize = 1, CancellationToken cancellation = default)
+        var filter = Builders<FileChunk<TId>>.Filter.Eq(c => c.FileID, _parent.ID);
+        var options = new FindOptions<FileChunk<TId>, byte[]>
         {
-            _parent.ThrowIfUnsaved();
-            if (!_parent.UploadSuccessful) throw new InvalidOperationException("Data for this file hasn't been uploaded successfully (yet)!");
-            if (!stream.CanWrite) throw new NotSupportedException("The supplied stream is not writable!");
-
-            var filter = Builders<FileChunk>.Filter.Eq(c => c.FileID, _parent.ID);
-            var options = new FindOptions<FileChunk, byte[]>
-            {
-                BatchSize = batchSize,
-                Sort = Builders<FileChunk>.Sort.Ascending(c => c.ID),
-                Projection = Builders<FileChunk>.Projection.Expression(c => c.Data)
-            };
+            BatchSize = batchSize,
+            Sort = Builders<FileChunk<TId>>.Sort.Ascending(c => c.ID),
+            Projection = Builders<FileChunk<TId>>.Projection.Expression(c => c.Data)
+        };
 
-            var findTask =
-                _db.Session is not IClientSessionHandle session
-                ? _chunkCollection.FindAsync(filter, options, cancellation)
-                : _chunkCollection.FindAsync(session, filter, options, cancellation);
+        var findTask =
+            _db.Session is not IClientSessionHandle session
+            ? _chunkCollection.FindAsync(filter, options, cancellation)
+            : _chunkCollection.FindAsync(session, filter, options, cancellation);
 
-            using var cursor = await findTask.ConfigureAwait(false);
-            var hasChunks = false;
+        using var cursor = await findTask.ConfigureAwait(false);
+        var hasChunks = false;
 
-            while (await cursor.MoveNextAsync(cancellation).ConfigureAwait(false))
+        while (await cursor.MoveNextAsync(cancellation).ConfigureAwait(false))
+        {
+            foreach (var chunk in cursor.Current)
             {
-                foreach (var chunk in cursor.Current)
-                {
-                    await stream.WriteAsync(chunk, 0, chunk.Length, cancellation).ConfigureAwait(false);
-                    hasChunks = true;
-                }
+                await stream.WriteAsync(chunk, 0, chunk.Length, cancellation).ConfigureAwait(false);
+                hasChunks = true;
             }
-
-            if (!hasChunks) throw new InvalidOperationException($"No data was found for file entity with ID: {_parent.ID}");
         }
 
-        /// <summary>
-        /// Upload binary data for this file entity into mongodb in chunks from a given stream with a timeout period.
-        /// </summary>
-        /// <param name="stream">The input stream to read the data from</param>
-        /// <param name="timeOutSeconds">The maximum number of seconds allowed for the operation to complete</param>
-        /// <param name="chunkSizeKB">The 'average' size of one chunk in KiloBytes</param>
-        public Task UploadWithTimeoutAsync(Stream stream, int timeOutSeconds, int chunkSizeKB = 256)
-        {
-            return UploadAsync(stream, chunkSizeKB, new CancellationTokenSource(timeOutSeconds * 1000).Token);
-        }
+        if (!hasChunks) throw new InvalidOperationException($"No data was found for file entity with ID: {_parent.ID}");
+    }
 
-        /// <summary>
-        /// Upload binary data for this file entity into mongodb in chunks from a given stream.
-        /// <para>TIP: Make sure to save the entity before calling this method.</para>
-        /// </summary>
-        /// <param name="stream">The input stream to read the data from</param>
-        /// <param name="chunkSizeKB">The 'average' size of one chunk in KiloBytes</param>
-        /// <param name="cancellation">An optional cancellation token.</param>
-        public async Task UploadAsync(Stream stream, int chunkSizeKB = 256, CancellationToken cancellation = default)
-        {
-            _parent.ThrowIfUnsaved();
-            if (chunkSizeKB < 128 || chunkSizeKB > 4096) throw new ArgumentException("Please specify a chunk size from 128KB to 4096KB");
-            if (!stream.CanRead) throw new NotSupportedException("The supplied stream is not readable!");
-            await CleanUpAsync().ConfigureAwait(false);
+    /// <summary>
+    /// Upload binary data for this file entity into mongodb in chunks from a given stream with a timeout period.
+    /// </summary>
+    /// <param name="stream">The input stream to read the data from</param>
+    /// <param name="timeOutSeconds">The maximum number of seconds allowed for the operation to complete</param>
+    /// <param name="chunkSizeKB">The 'average' size of one chunk in KiloBytes</param>
+    public Task UploadWithTimeoutAsync(Stream stream, int timeOutSeconds, int chunkSizeKB = 256)
+    {
+        return UploadAsync(stream, chunkSizeKB, new CancellationTokenSource(timeOutSeconds * 1000).Token);
+    }
 
-            _doc = new FileChunk { FileID = _parent.ID };
-            _chunkSize = chunkSizeKB * 1024;
-            _dataChunk = new List<byte>(_chunkSize);
-            _buffer = new byte[64 * 1024]; // 64kb read buffer
-            _readCount = 0;
+    /// <summary>
+    /// Upload binary data for this file entity into mongodb in chunks from a given stream.
+    /// <para>TIP: Make sure to save the entity before calling this method.</para>
+    /// </summary>
+    /// <param name="stream">The input stream to read the data from</param>
+    /// <param name="chunkSizeKB">The 'average' size of one chunk in KiloBytes</param>
+    /// <param name="cancellation">An optional cancellation token.</param>
+    public async Task UploadAsync(Stream stream, int chunkSizeKB = 256, CancellationToken cancellation = default)
+    {
+        _parent.ThrowIfUnsaved();
+        if (chunkSizeKB < 128 || chunkSizeKB > 4096) throw new ArgumentException("Please specify a chunk size from 128KB to 4096KB");
+        if (!stream.CanRead) throw new NotSupportedException("The supplied stream is not readable!");
+        await CleanUpAsync().ConfigureAwait(false);
 
-            if (!string.IsNullOrEmpty(_parent.MD5))
-                _md5 = MD5.Create();
+        _doc = new FileChunk<TId> { FileID = _parent.ID };
+        _chunkSize = chunkSizeKB * 1024;
+        _dataChunk = new List<byte>(_chunkSize);
+        _buffer = new byte[64 * 1024]; // 64kb read buffer
+        _readCount = 0;
 
-            try
-            {
-                if (stream.CanSeek && stream.Position > 0) stream.Position = 0;
+        if (!string.IsNullOrEmpty(_parent.MD5))
+            _md5 = MD5.Create();
 
-                while ((_readCount = await stream.ReadAsync(_buffer, 0, _buffer.Length, cancellation).ConfigureAwait(false)) > 0)
-                {
-                    _md5?.TransformBlock(_buffer, 0, _readCount, null, 0);
-                    await FlushToDBAsync(isLastChunk: false, cancellation).ConfigureAwait(false);
-                }
+        try
+        {
+            if (stream.CanSeek && stream.Position > 0) stream.Position = 0;
 
-                if (_parent.FileSize > 0)
-                {
-                    _md5?.TransformFinalBlock(_buffer, 0, _readCount);
-                    if (_md5 != null && !BitConverter.ToString(_md5.Hash).Replace("-", "").Equals(_parent.MD5, StringComparison.OrdinalIgnoreCase))
-                    {
-                        throw new InvalidDataException("MD5 of uploaded data doesn't match with file entity MD5.");
-                    }
-                    await FlushToDBAsync(isLastChunk: true, cancellation).ConfigureAwait(false);
-                    _parent.UploadSuccessful = true;
-                }
-                else
-                {
-                    throw new InvalidOperationException("The supplied stream had no data to read (probably closed)");
-                }
+            while ((_readCount = await stream.ReadAsync(_buffer, 0, _buffer.Length, cancellation).ConfigureAwait(false)) > 0)
+            {
+                _md5?.TransformBlock(_buffer, 0, _readCount, null, 0);
+                await FlushToDBAsync(isLastChunk: false, cancellation).ConfigureAwait(false);
             }
-            catch (Exception)
+
+            if (_parent.FileSize > 0)
             {
-                await CleanUpAsync().ConfigureAwait(false);
-                throw;
+                _md5?.TransformFinalBlock(_buffer, 0, _readCount);
+                if (_md5 != null && !BitConverter.ToString(_md5.Hash).Replace("-", "").Equals(_parent.MD5, StringComparison.OrdinalIgnoreCase))
+                {
+                    throw new InvalidDataException("MD5 of uploaded data doesn't match with file entity MD5.");
+                }
+                await FlushToDBAsync(isLastChunk: true, cancellation).ConfigureAwait(false);
+                _parent.UploadSuccessful = true;
             }
-            finally
+            else
             {
-                await UpdateMetaDataAsync().ConfigureAwait(false);
-                _doc = null;
-                _buffer = null;
-                _dataChunk = null;
-                _md5?.Dispose();
-                _md5 = null;
+                throw new InvalidOperationException("The supplied stream had no data to read (probably closed)");
             }
         }
-
-        /// <summary>
-        /// Deletes only the binary chunks stored in the database for this file entity.
-        /// </summary>
-        /// <param name="cancellation">An optional cancellation token.</param>
-        public Task DeleteBinaryChunks(CancellationToken cancellation = default)
+        catch (Exception)
         {
-            _parent.ThrowIfUnsaved();
-
-            if (cancellation != default && _db.Session == null)
-                throw new NotSupportedException("Cancellation is only supported within transactions for deleting binary chunks!");
-
-            return CleanUpAsync(cancellation);
+            await CleanUpAsync().ConfigureAwait(false);
+            throw;
         }
-
-        private Task CleanUpAsync(CancellationToken cancellation = default)
+        finally
         {
-            _parent.FileSize = 0;
-            _parent.ChunkCount = 0;
-            _parent.UploadSuccessful = false;
-            return _db.Session is not IClientSessionHandle session
-                   ? _chunkCollection.DeleteManyAsync(c => c.FileID == _parent.ID, cancellation)
-                   : _chunkCollection.DeleteManyAsync(session, c => c.FileID == _parent.ID, null, cancellation);
+            await UpdateMetaDataAsync().ConfigureAwait(false);
+            _doc = null;
+            _buffer = null;
+            _dataChunk = null;
+            _md5?.Dispose();
+            _md5 = null;
         }
+    }
 
-        private Task FlushToDBAsync(bool isLastChunk = false, CancellationToken cancellation = default)
-        {
-            if (!isLastChunk)
-            {
-                _dataChunk?.AddRange(new ArraySegment<byte>(_buffer, 0, _readCount));
-                _parent.FileSize += _readCount;
-            }
-            if (_doc is null)
-            {
-                return Task.CompletedTask;
-            }
-            if (_dataChunk is not null && (_dataChunk.Count >= _chunkSize || isLastChunk))
-            {
+    /// <summary>
+    /// Deletes only the binary chunks stored in the database for this file entity.
+    /// </summary>
+    /// <param name="cancellation">An optional cancellation token.</param>
+    public Task DeleteBinaryChunks(CancellationToken cancellation = default)
+    {
+        _parent.ThrowIfUnsaved();
 
-                _doc.ID = _doc.GenerateNewID();
-                _doc.Data = _dataChunk.ToArray();
-                _dataChunk.Clear();
-                _parent.ChunkCount++;
-                return _db.Session is not IClientSessionHandle session
-                       ? _chunkCollection.InsertOneAsync(_doc, null, cancellation)
-                       : _chunkCollection.InsertOneAsync(session, _doc, null, cancellation);
-            }
+        if (cancellation != default && _db.Session == null)
+            throw new NotSupportedException("Cancellation is only supported within transactions for deleting binary chunks!");
+
+        return CleanUpAsync(cancellation);
+    }
 
+    private Task CleanUpAsync(CancellationToken cancellation = default)
+    {
+        _parent.FileSize = 0;
+        _parent.ChunkCount = 0;
+        _parent.UploadSuccessful = false;
+        var filter = Builders<FileChunk<TId>>.Filter.Eq(c => c.FileID, _parent.ID);
+        return _db.Session is not IClientSessionHandle session
+               ? _chunkCollection.DeleteManyAsync(filter, cancellation)
+               : _chunkCollection.DeleteManyAsync(session, filter, cancellationToken: cancellation);
+    }
+
+    private Task FlushToDBAsync(bool isLastChunk = false, CancellationToken cancellation = default)
+    {
+        if (!isLastChunk)
+        {
+            _dataChunk?.AddRange(new ArraySegment<byte>(_buffer, 0, _readCount));
+            _parent.FileSize += _readCount;
+        }
+        if (_doc is null)
+        {
             return Task.CompletedTask;
         }
-
-        private Task UpdateMetaDataAsync()
+        if (_dataChunk is not null && (_dataChunk.Count >= _chunkSize || isLastChunk))
         {
-            var filter = Builders<T>.Filter.Eq(e => e.ID, _parent.ID);
-            var update = Builders<T>.Update
-                            .Set(e => e.FileSize, _parent.FileSize)
-                            .Set(e => e.ChunkCount, _parent.ChunkCount)
-                            .Set(e => e.UploadSuccessful, _parent.UploadSuccessful);
 
+            _doc.ID = _doc.GenerateNewID();
+            _doc.Data = _dataChunk.ToArray();
+            _dataChunk.Clear();
+            _parent.ChunkCount++;
             return _db.Session is not IClientSessionHandle session
-                   ? _collection.UpdateOneAsync(filter, update)
-                   : _collection.UpdateOneAsync(session, filter, update);
+                   ? _chunkCollection.InsertOneAsync(_doc, null, cancellation)
+                   : _chunkCollection.InsertOneAsync(session, _doc, null, cancellation);
         }
+
+        return Task.CompletedTask;
+    }
+
+    private Task UpdateMetaDataAsync()
+    {
+        var filter = Builders<T>.Filter.Eq(e => e.ID, _parent.ID);
+        var update = Builders<T>.Update
+                        .Set(e => e.FileSize, _parent.FileSize)
+                        .Set(e => e.ChunkCount, _parent.ChunkCount)
+                        .Set(e => e.UploadSuccessful, _parent.UploadSuccessful);
+
+        return _db.Session is not IClientSessionHandle session
+               ? _collection.UpdateOneAsync(filter, update)
+               : _collection.UpdateOneAsync(session, filter, update);
     }
 }
diff --git a/MongoDB.Entities/Core/FuzzyString.cs b/MongoDB.Entities/Core/FuzzyString.cs
index 21b71164d..3ca037037 100644
--- a/MongoDB.Entities/Core/FuzzyString.cs
+++ b/MongoDB.Entities/Core/FuzzyString.cs
@@ -1,102 +1,97 @@
-using MongoDB.Bson;
-using MongoDB.Bson.IO;
-using MongoDB.Bson.Serialization;
-using MongoDB.Bson.Serialization.Serializers;
-using System;
+using MongoDB.Bson.IO;
 
-namespace MongoDB.Entities
+namespace MongoDB.Entities;
+
+internal class FuzzyStringSerializer : SerializerBase<FuzzyString?>, IBsonDocumentSerializer
 {
-    internal class FuzzyStringSerializer : SerializerBase<FuzzyString>, IBsonDocumentSerializer
-    {
-        private static readonly StringSerializer strSerializer = new();
+    private static readonly StringSerializer _strSerializer = new();
 
-        public override void Serialize(BsonSerializationContext ctx, BsonSerializationArgs args, FuzzyString fString)
+    public override void Serialize(BsonSerializationContext ctx, BsonSerializationArgs args, FuzzyString? fString)
+    {
+        if (fString == null || string.IsNullOrWhiteSpace(fString.Value))
         {
-            if (fString == null || string.IsNullOrWhiteSpace(fString.Value))
-            {
-                ctx.Writer.WriteNull();
-            }
-            else
-            {
-                if (fString.Value.Length > FuzzyString.CharacterLimit)
-                    throw new NotSupportedException($"FuzzyString can only hold a maximum of {FuzzyString.CharacterLimit} characters!");
-
-                ctx.Writer.WriteStartDocument();
-                ctx.Writer.WriteString("Value", fString.Value);
-                ctx.Writer.WriteString("Hash", fString.Value.ToDoubleMetaphoneHash());
-                ctx.Writer.WriteEndDocument();
-            }
+            ctx.Writer.WriteNull();
         }
-
-        public override FuzzyString Deserialize(BsonDeserializationContext ctx, BsonDeserializationArgs args)
+        else
         {
-            var bsonType = ctx.Reader.GetCurrentBsonType();
+            if (fString.Value!.Length > FuzzyString.CharacterLimit)
+                throw new NotSupportedException($"FuzzyString can only hold a maximum of {FuzzyString.CharacterLimit} characters!");
 
-            switch (bsonType)
-            {
-                case BsonType.Document:
+            ctx.Writer.WriteStartDocument();
+            ctx.Writer.WriteString(nameof(FuzzyString.Value), fString.Value);
+            ctx.Writer.WriteString("Hash", fString.Value.ToDoubleMetaphoneHash());
+            ctx.Writer.WriteEndDocument();
+        }
+    }
 
-                    string value = null;
+    public override FuzzyString? Deserialize(BsonDeserializationContext ctx, BsonDeserializationArgs args)
+    {
+        var bsonType = ctx.Reader.GetCurrentBsonType();
+
+        switch (bsonType)
+        {
+            case BsonType.Document:
 
-                    ctx.Reader.ReadStartDocument();
-                    while (ctx.Reader.ReadBsonType() != BsonType.EndOfDocument)
-                    {
-                        if (ctx.Reader.ReadName() == "Value")
-                            value = ctx.Reader.ReadString();
-                        else
-                            ctx.Reader.SkipValue();
-                    }
-                    ctx.Reader.ReadEndDocument();
+                string? value = null;
 
-                    if (value == null)
-                        throw new FormatException("Unable to deserialize a value from the FuzzyString document!");
+                ctx.Reader.ReadStartDocument();
+                while (ctx.Reader.ReadBsonType() != BsonType.EndOfDocument)
+                {
+                    if (ctx.Reader.ReadName() == nameof(FuzzyString.Value))
+                        value = ctx.Reader.ReadString();
+                    else
+                        ctx.Reader.SkipValue();
+                }
+                ctx.Reader.ReadEndDocument();
 
-                    return value;
+                if (value == null)
+                    throw new FormatException("Unable to deserialize a value from the FuzzyString document!");
 
-                case BsonType.Null:
-                    ctx.Reader.ReadNull();
-                    return null;
+                return value;
 
-                default:
-                    throw new FormatException($"Cannot deserialize a FuzzyString value from a [{bsonType}]");
-            }
+            case BsonType.Null:
+                ctx.Reader.ReadNull();
+                return null;
+
+            default:
+                throw new FormatException($"Cannot deserialize a FuzzyString value from a [{bsonType}]");
         }
+    }
 
-        public bool TryGetMemberSerializationInfo(string memberName, out BsonSerializationInfo serializationInfo)
+    public bool TryGetMemberSerializationInfo(string memberName, out BsonSerializationInfo? serializationInfo)
+    {
+        switch (memberName)
         {
-            switch (memberName)
-            {
-                case "Value":
-                    serializationInfo = new BsonSerializationInfo("Value", strSerializer, typeof(string));
-                    return true;
-                default:
-                    serializationInfo = null;
-                    return false;
-            }
+            case "Value":
+                serializationInfo = new BsonSerializationInfo("Value", _strSerializer, typeof(string));
+                return true;
+            default:
+                serializationInfo = null;
+                return false;
         }
     }
+}
 
-    /// <summary>
-    /// Use this type to store strings if you need fuzzy text searching with MongoDB
-    /// <para>TIP: There's a default limit of 250 characters for ensuring best performance.
-    /// If you exceed the default limit, an exception will be thrown.
-    /// You can increase the limit by sacrificing performance/resource utilization by setting the static property
-    /// <c>FuzzyString.CharacterLimit = 500</c> at startup.</para>
-    /// </summary>
-    public class FuzzyString
-    {
-        public static int CharacterLimit { get; set; } = 250;
+/// <summary>
+/// Use this type to store strings if you need fuzzy text searching with MongoDB
+/// <para>TIP: There's a default limit of 250 characters for ensuring best performance.
+/// If you exceed the default limit, an exception will be thrown.
+/// You can increase the limit by sacrificing performance/resource utilization by setting the static property
+/// <c>FuzzyString.CharacterLimit = 500</c> at startup.</para>
+/// </summary>
+public class FuzzyString
+{
+    public static int CharacterLimit { get; set; } = 250;
 
-        public string Value { get; set; }
+    public string? Value { get; set; }
 
-        public static implicit operator FuzzyString(string value)
-        {
-            return new FuzzyString { Value = value };
-        }
+    public static implicit operator FuzzyString(string value)
+    {
+        return new FuzzyString { Value = value };
+    }
 
-        public static implicit operator string(FuzzyString fuzzyString)
-        {
-            return fuzzyString.Value;
-        }
+    public static implicit operator string?(FuzzyString fuzzyString)
+    {
+        return fuzzyString.Value;
     }
 }
diff --git a/MongoDB.Entities/Core/GeoNear.cs b/MongoDB.Entities/Core/GeoNear.cs
index cddf561d2..027d657a5 100644
--- a/MongoDB.Entities/Core/GeoNear.cs
+++ b/MongoDB.Entities/Core/GeoNear.cs
@@ -1,73 +1,69 @@
-using MongoDB.Bson;
-using MongoDB.Bson.Serialization.Attributes;
-using MongoDB.Driver;
-using MongoDB.Driver.GeoJsonObjectModel;
+using MongoDB.Driver.GeoJsonObjectModel;
 
-namespace MongoDB.Entities
+namespace MongoDB.Entities;
+
+/// <summary>
+/// Represents a 2D geographical coordinate consisting of longitude and latitude
+/// </summary>
+public class Coordinates2D
 {
+    [BsonElement("type")]
+    public string Type { get; set; }
+
+    [BsonElement("coordinates")]
+    public double[] Coordinates { get; set; }
+
     /// <summary>
-    /// Represents a 2D geographical coordinate consisting of longitude and latitude
+    /// Instantiate a new Coordinates2D instance with the supplied longtitude and latitude
     /// </summary>
-    public class Coordinates2D
+    public Coordinates2D(double longitude, double latitude)
     {
-        [BsonElement("type")]
-        public string Type { get; set; }
-
-        [BsonElement("coordinates")]
-        public double[] Coordinates { get; set; }
-
-        /// <summary>
-        /// Instantiate a new Coordinates2D instance with the supplied longtitude and latitude
-        /// </summary>
-        public Coordinates2D(double longitude, double latitude)
-        {
-            Type = "Point";
-            Coordinates = new[] { longitude, latitude };
-        }
-
-        /// <summary>
-        /// Converts a Coordinates2D instance to a GeoJsonPoint of GeoJson2DGeographicCoordinates 
-        /// </summary>
-        public GeoJsonPoint<GeoJson2DGeographicCoordinates> ToGeoJsonPoint()
-        {
-            return GeoJson.Point(GeoJson.Geographic(Coordinates[0], Coordinates[1]));
-        }
+        Type = "Point";
+        Coordinates = new[] { longitude, latitude };
+    }
 
-        /// <summary>
-        /// Create a GeoJsonPoint of GeoJson2DGeographicCoordinates with supplied longitude and latitude
-        /// </summary>
-        public static GeoJsonPoint<GeoJson2DGeographicCoordinates> GeoJsonPoint(double longitude, double latitude)
-        {
-            return GeoJson.Point(GeoJson.Geographic(longitude, latitude));
-        }
+    /// <summary>
+    /// Converts a Coordinates2D instance to a GeoJsonPoint of GeoJson2DGeographicCoordinates 
+    /// </summary>
+    public GeoJsonPoint<GeoJson2DGeographicCoordinates> ToGeoJsonPoint()
+    {
+        return GeoJson.Point(GeoJson.Geographic(Coordinates[0], Coordinates[1]));
     }
 
     /// <summary>
-    /// Fluent aggregation pipeline builder for GeoNear
+    /// Create a GeoJsonPoint of GeoJson2DGeographicCoordinates with supplied longitude and latitude
     /// </summary>
-    /// <typeparam name="T">The type of entity</typeparam>
-    public class GeoNear<T> where T : IEntity
+    public static GeoJsonPoint<GeoJson2DGeographicCoordinates> GeoJsonPoint(double longitude, double latitude)
     {
+        return GeoJson.Point(GeoJson.Geographic(longitude, latitude));
+    }
+}
+
+/// <summary>
+/// Fluent aggregation pipeline builder for GeoNear
+/// </summary>
+/// <typeparam name="T">The type of entity</typeparam>
+public class GeoNear<T>
+{
 #pragma warning disable IDE1006
-        public Coordinates2D near { get; set; } = null!;
-        public string? distanceField { get; set; }
-        public bool spherical { get; set; }
-        [BsonIgnoreIfNull] public int? limit { get; set; }
-        [BsonIgnoreIfNull] public double? maxDistance { get; set; }
-        [BsonIgnoreIfNull] public BsonDocument? query { get; set; }
-        [BsonIgnoreIfNull] public double? distanceMultiplier { get; set; }
-        [BsonIgnoreIfNull] public string? includeLocs { get; set; }
-        [BsonIgnoreIfNull] public double? minDistance { get; set; }
-        [BsonIgnoreIfNull] public string? key { get; set; }
+    public Coordinates2D near { get; set; } = null!;
+    public string? distanceField { get; set; }
+    public bool spherical { get; set; }
+    [BsonIgnoreIfNull] public int? limit { get; set; }
+    [BsonIgnoreIfNull] public double? maxDistance { get; set; }
+    [BsonIgnoreIfNull] public BsonDocument? query { get; set; }
+    [BsonIgnoreIfNull] public double? distanceMultiplier { get; set; }
+    [BsonIgnoreIfNull] public string? includeLocs { get; set; }
+    [BsonIgnoreIfNull] public double? minDistance { get; set; }
+    [BsonIgnoreIfNull] public string? key { get; set; }
 #pragma warning restore IDE1006
 
-        internal IAggregateFluent<T> ToFluent(DBContext context, AggregateOptions? options = null, string? collectionName = null, IMongoCollection<T>? collection = null)
-        {
-            var stage = new BsonDocument { { "$geoNear", this.ToBsonDocument() } };
+    internal IAggregateFluent<T> ToFluent(DBContext context, AggregateOptions? options = null, string? collectionName = null, IMongoCollection<T>? collection = null)
+    {
+        var stage = new BsonDocument { { "$geoNear", this.ToBsonDocument() } };
 
-            return context.Session == null
-                    ? context.Collection(collectionName, collection).Aggregate(options).AppendStage<T>(stage)
-                    : context.Collection(collectionName, collection).Aggregate(context.Session, options).AppendStage<T>(stage);
-        }
+        return context.Session == null
+                ? context.Collection(collectionName, collection).Aggregate(options).AppendStage<T>(stage)
+                : context.Collection(collectionName, collection).Aggregate(context.Session, options).AppendStage<T>(stage);
     }
 }
diff --git a/MongoDB.Entities/Core/ICreatedOn.cs b/MongoDB.Entities/Core/ICreatedOn.cs
index d20b33e44..80d94781b 100644
--- a/MongoDB.Entities/Core/ICreatedOn.cs
+++ b/MongoDB.Entities/Core/ICreatedOn.cs
@@ -1,16 +1,13 @@
-using System;
+namespace MongoDB.Entities;
 
-namespace MongoDB.Entities
+/// <summary>
+/// Implement this interface on entities you want the library to automatically store the creation date with
+/// </summary>
+public interface ICreatedOn
 {
     /// <summary>
-    /// Implement this interface on entities you want the library to automatically store the creation date with
+    /// This property will be automatically set by the library when an entity is created.
+    /// <para>TIP: This property is useful when sorting by creation date.</para>
     /// </summary>
-    public interface ICreatedOn
-    {
-        /// <summary>
-        /// This property will be automatically set by the library when an entity is created.
-        /// <para>TIP: This property is useful when sorting by creation date.</para>
-        /// </summary>
-        DateTime CreatedOn { get; set; }
-    }
+    DateTime CreatedOn { get; set; }
 }
diff --git a/MongoDB.Entities/Core/IEntity.cs b/MongoDB.Entities/Core/IEntity.cs
index 5589e08fe..cc9399b8d 100644
--- a/MongoDB.Entities/Core/IEntity.cs
+++ b/MongoDB.Entities/Core/IEntity.cs
@@ -1,21 +1,47 @@
-namespace MongoDB.Entities
+namespace MongoDB.Entities;
+
+/// <summary>
+/// The contract for Entity classes
+/// </summary>
+public interface IEntity : IEntity<string>
+{
+
+}
+
+/// <summary>
+/// The contract for Entity classes
+/// </summary>
+public interface IEntity<TId>
+    where TId : IComparable<TId>, IEquatable<TId>
 {
     /// <summary>
-    /// The contract for Entity classes
+    /// The ID property for this entity type.
+    /// <para>IMPORTANT: make sure to decorate this property with the [BsonId] attribute when implementing this interface</para>
+    /// </summary>
+    TId? ID { get; set; }
+
+    /// <summary>
+    /// Generate and return a new ID string from this method. It will be used when saving new entities that don't have their ID set. 
+    /// That is, if an entity has a null ID, this method will be called for getting a new ID value. 
+    /// If you're not doing custom ID generation, simply do <c>return ObjectId.GenerateNewId().ToString()</c>
     /// </summary>
-    public interface IEntity
-    {
-        /// <summary>
-        /// The ID property for this entity type.
-        /// <para>IMPORTANT: make sure to decorate this property with the [BsonId] attribute when implementing this interface</para>
-        /// </summary>
-        string? ID { get; set; }
+    TId GenerateNewID();
+}
 
-        /// <summary>
-        /// Generate and return a new ID string from this method. It will be used when saving new entities that don't have their ID set. 
-        /// That is, if an entity has a null ID, this method will be called for getting a new ID value. 
-        /// If you're not doing custom ID generation, simply do <c>return ObjectId.GenerateNewId().ToString()</c>
-        /// </summary>
-        string GenerateNewID();
-    }
-}
\ No newline at end of file
+//public class MultipleIdEntity : IEntity<ValueTuple<Guid, ObjectId>>
+//{
+//    public (Guid, ObjectId) ID { get; set; }
+//    [BsonIgnore]
+//    public Guid Id1
+//    {
+//        get => ID.Item1;
+//        set => ID = (value, ID.Item2);
+//    }
+//    [BsonIgnore]
+//    public ObjectId Id2
+//    {
+//        get => ID.Item2;
+//        set => ID = (ID.Item1, value);
+//    }
+//    public (Guid, ObjectId) GenerateNewID() => (Guid.NewGuid(), ObjectId.GenerateNewId());
+//}
\ No newline at end of file
diff --git a/MongoDB.Entities/Core/IModifiedOn.cs b/MongoDB.Entities/Core/IModifiedOn.cs
index dd305629e..d00e29cbb 100644
--- a/MongoDB.Entities/Core/IModifiedOn.cs
+++ b/MongoDB.Entities/Core/IModifiedOn.cs
@@ -1,16 +1,13 @@
-using System;
+namespace MongoDB.Entities;
 
-namespace MongoDB.Entities
+/// <summary>
+/// Implement this interface on entities you want the library to automatically store the modified date with
+/// </summary>
+public interface IModifiedOn
 {
     /// <summary>
-    /// Implement this interface on entities you want the library to automatically store the modified date with
+    /// This property will be automatically set by the library when an entity is updated.
+    /// <para>TIP: This property is useful when sorting by update date.</para>
     /// </summary>
-    public interface IModifiedOn
-    {
-        /// <summary>
-        /// This property will be automatically set by the library when an entity is updated.
-        /// <para>TIP: This property is useful when sorting by update date.</para>
-        /// </summary>
-        DateTime ModifiedOn { get; set; }
-    }
+    DateTime ModifiedOn { get; set; }
 }
diff --git a/MongoDB.Entities/Core/IgnoreManyPropsConvention.cs b/MongoDB.Entities/Core/IgnoreManyPropsConvention.cs
index 1d9b7f9f0..859ab0c03 100644
--- a/MongoDB.Entities/Core/IgnoreManyPropsConvention.cs
+++ b/MongoDB.Entities/Core/IgnoreManyPropsConvention.cs
@@ -1,16 +1,14 @@
-using MongoDB.Bson.Serialization;
-using MongoDB.Bson.Serialization.Conventions;
+using MongoDB.Bson.Serialization.Conventions;
 
-namespace MongoDB.Entities
+namespace MongoDB.Entities;
+
+internal class IgnoreManyPropsConvention : ConventionBase, IMemberMapConvention
 {
-    internal class IgnoreManyPropsConvention : ConventionBase, IMemberMapConvention
+    public void Apply(BsonMemberMap mMap)
     {
-        public void Apply(BsonMemberMap mMap)
+        if (mMap.MemberType.Name == ManyBase.PropTypeName)
         {
-            if (mMap.MemberType.Name == ManyBase.PropTypeName)
-            {
-                _ = mMap.SetShouldSerializeMethod(_ => false);
-            }
+            _ = mMap.SetShouldSerializeMethod(_ => false);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/MongoDB.Entities/Core/LevenshteinDistance.cs b/MongoDB.Entities/Core/LevenshteinDistance.cs
index e51364d3c..b86366ea1 100644
--- a/MongoDB.Entities/Core/LevenshteinDistance.cs
+++ b/MongoDB.Entities/Core/LevenshteinDistance.cs
@@ -1,65 +1,64 @@
-namespace MongoDB.Entities
+namespace MongoDB.Entities;
+
+internal class Levenshtein
 {
-    internal class Levenshtein
+    private readonly string _storedValue;
+    private readonly int[] _costs;
+
+    public Levenshtein(string value)
+    {
+        _storedValue = value.ToLower();
+        _costs = new int[_storedValue.Length];
+    }
+
+    public int DistanceFrom(string value)
     {
-        private readonly string storedValue;
-        private readonly int[] costs;
+        value = value.ToLower();
 
-        public Levenshtein(string value)
+        if (_costs.Length == 0)
         {
-            storedValue = value.ToLower();
-            costs = new int[storedValue.Length];
+            return value.Length;
         }
 
-        public int DistanceFrom(string value)
+        for (int i = 0; i < _costs.Length;)
         {
-            value = value.ToLower();
+            _costs[i] = ++i;
+        }
 
-            if (costs.Length == 0)
-            {
-                return value.Length;
-            }
+        for (int i = 0; i < value.Length; i++)
+        {
+            int cost = i;
+            int addationCost = i;
 
-            for (int i = 0; i < costs.Length;)
-            {
-                costs[i] = ++i;
-            }
+            char value1Char = value[i];
 
-            for (int i = 0; i < value.Length; i++)
+            for (int j = 0; j < _storedValue.Length; j++)
             {
-                int cost = i;
-                int addationCost = i;
+                int insertionCost = cost;
 
-                char value1Char = value[i];
+                cost = addationCost;
 
-                for (int j = 0; j < storedValue.Length; j++)
-                {
-                    int insertionCost = cost;
-
-                    cost = addationCost;
-
-                    addationCost = costs[j];
+                addationCost = _costs[j];
 
-                    if (value1Char != storedValue[j])
+                if (value1Char != _storedValue[j])
+                {
+                    if (insertionCost < cost)
                     {
-                        if (insertionCost < cost)
-                        {
-                            cost = insertionCost;
-                        }
-
-                        if (addationCost < cost)
-                        {
-                            cost = addationCost;
-                        }
+                        cost = insertionCost;
+                    }
 
-                        ++cost;
+                    if (addationCost < cost)
+                    {
+                        cost = addationCost;
                     }
 
-                    costs[j] = cost;
+                    ++cost;
                 }
-            }
 
-            return costs[costs.Length - 1];
+                _costs[j] = cost;
+            }
         }
+
+        return _costs[_costs.Length - 1];
     }
 }
diff --git a/MongoDB.Entities/Core/Logic.cs b/MongoDB.Entities/Core/Logic.cs
index abb12cd7d..dac217f7f 100644
--- a/MongoDB.Entities/Core/Logic.cs
+++ b/MongoDB.Entities/Core/Logic.cs
@@ -1,62 +1,54 @@
-using MongoDB.Bson;
-using MongoDB.Driver;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Linq.Expressions;
-
-namespace MongoDB.Entities
+namespace MongoDB.Entities;
+
+internal static class Logic
 {
-    internal static class Logic
+    internal static IEnumerable<UpdateDefinition<T>> BuildUpdateDefs<T>(T entity, DBContext context)
     {
-        internal static IEnumerable<UpdateDefinition<T>> BuildUpdateDefs<T>(T entity, DBContext? context = null) where T : IEntity
-        {
-            if (entity == null)
-                throw new ArgumentException("The supplied entity cannot be null!");
+        if (entity == null)
+            throw new ArgumentException("The supplied entity cannot be null!");
 
-            var props = (context?.Cache<T>() ?? EntityCache<T>.Instance).UpdatableProps(entity);
+        var props = context.Cache<T>().UpdatableProps(entity);
 
-            return props.Select(p => Builders<T>.Update.Set(p.Name, p.GetValue(entity)));
-        }
+        return props.Select(p => Builders<T>.Update.Set(p.Name, p.GetValue(entity)));
+    }
 
-        internal static IEnumerable<UpdateDefinition<T>> BuildUpdateDefs<T>(T entity, Expression<Func<T, object>> members, bool excludeMode = false, DBContext? context = null) where T : IEntity
-        {
-            var propNames = (members?.Body as NewExpression)?.Arguments
-                .Select(a => a.ToString().Split('.')[1]);
+    internal static IEnumerable<UpdateDefinition<T>> BuildUpdateDefs<T>(T entity, Expression<Func<T, object>> members, DBContext context, bool excludeMode = false)
+    {
+        var propNames = (members?.Body as NewExpression)?.Arguments
+            .Select(a => a.ToString().Split('.')[1]);
 
-            if (!propNames.Any())
-                throw new ArgumentException("Unable to get any properties from the members expression!");
+        if (!propNames.Any())
+            throw new ArgumentException("Unable to get any properties from the members expression!");
 
-            var props = (context?.Cache<T>() ?? EntityCache<T>.Instance).UpdatableProps(entity);
+        var props = context.Cache<T>().UpdatableProps(entity);
 
-            if (excludeMode)
-                props = props.Where(p => !propNames.Contains(p.Name));
-            else
-                props = props.Where(p => propNames.Contains(p.Name));
+        if (excludeMode)
+            props = props.Where(p => !propNames.Contains(p.Name));
+        else
+            props = props.Where(p => propNames.Contains(p.Name));
 
-            return props.Select(p => Builders<T>.Update.Set(p.Name, p.GetValue(entity)));
-        }
+        return props.Select(p => Builders<T>.Update.Set(p.Name, p.GetValue(entity)));
+    }
 
-        internal static FilterDefinition<T> MergeWithGlobalFilter<T>(bool ignoreGlobalFilters, Dictionary<Type, (object filterDef, bool prepend)>? globalFilters, FilterDefinition<T> filter) where T : IEntity
-        {
-            //WARNING: this has to do the same thing as DBContext.Pipeline.MergeWithGlobalFilter method
-            //         if the following logic changes, update the other method also
+    internal static FilterDefinition<T> MergeWithGlobalFilter<T>(bool ignoreGlobalFilters, Dictionary<Type, (object filterDef, bool prepend)>? globalFilters, FilterDefinition<T> filter)
+    {
+        //WARNING: this has to do the same thing as DBContext.Pipeline.MergeWithGlobalFilter method
+        //         if the following logic changes, update the other method also
 
-            if (!ignoreGlobalFilters && globalFilters is not null && globalFilters.Count > 0 && globalFilters.TryGetValue(typeof(T), out var gFilter))
+        if (!ignoreGlobalFilters && globalFilters is not null && globalFilters.Count > 0 && globalFilters.TryGetValue(typeof(T), out var gFilter))
+        {
+            switch (gFilter.filterDef)
             {
-                switch (gFilter.filterDef)
-                {
-                    case FilterDefinition<T> definition:
-                        return (gFilter.prepend) ? definition & filter : filter & definition;
+                case FilterDefinition<T> definition:
+                    return (gFilter.prepend) ? definition & filter : filter & definition;
 
-                    case BsonDocument bsonDoc:
-                        return (gFilter.prepend) ? bsonDoc & filter : filter & bsonDoc;
+                case BsonDocument bsonDoc:
+                    return (gFilter.prepend) ? bsonDoc & filter : filter & bsonDoc;
 
-                    case string jsonString:
-                        return (gFilter.prepend) ? jsonString & filter : filter & jsonString;
-                }
+                case string jsonString:
+                    return (gFilter.prepend) ? jsonString & filter : filter & jsonString;
             }
-            return filter;
         }
+        return filter;
     }
 }
diff --git a/MongoDB.Entities/Core/ModifiedBy.cs b/MongoDB.Entities/Core/ModifiedBy.cs
index ebb6506ce..c94244460 100644
--- a/MongoDB.Entities/Core/ModifiedBy.cs
+++ b/MongoDB.Entities/Core/ModifiedBy.cs
@@ -1,8 +1,7 @@
-namespace MongoDB.Entities
+namespace MongoDB.Entities;
+
+public class ModifiedBy
 {
-    public class ModifiedBy
-    {
-        [AsObjectId] public string UserID { get; set; }
-        public string UserName { get; set; }
-    }
+    [AsObjectId] public string UserID { get; set; }
+    public string UserName { get; set; }
 }
diff --git a/MongoDB.Entities/Core/Prop.cs b/MongoDB.Entities/Core/Prop.cs
index 81a92d6a1..b2291f6c0 100644
--- a/MongoDB.Entities/Core/Prop.cs
+++ b/MongoDB.Entities/Core/Prop.cs
@@ -1,147 +1,135 @@
-using System;
-using System.Linq.Expressions;
-using System.Text.RegularExpressions;
+using System.Text.RegularExpressions;
 
-namespace MongoDB.Entities
+namespace MongoDB.Entities;
+
+/// <summary>
+/// This class provides methods to generate property path strings from lambda expression. 
+/// </summary>
+public static class Prop
 {
-    /// <summary>
-    /// This class provides methods to generate property path strings from lambda expression. 
-    /// </summary>
-    public static class Prop
-    {
-        private static readonly Regex rxOne = new(@"(?:\.(?:\w+(?:[[(]\d+[)\]])?))+", RegexOptions.Compiled);//matched result: One.Two[1].Three.get_Item(2).Four
-        private static readonly Regex rxTwo = new(@".get_Item\((\d+)\)", RegexOptions.Compiled);//replaced result: One.Two[1].Three[2].Four
-        private static readonly Regex rxThree = new(@"\[\d+\]", RegexOptions.Compiled);
-        private static readonly Regex rxFour = new(@"\[(\d+)\]", RegexOptions.Compiled);
+    private static readonly Regex _rxOne = new(@"(?:\.(?:\w+(?:[[(]\d+[)\]])?))+", RegexOptions.Compiled);//matched result: One.Two[1].Three.get_Item(2).Four
+    private static readonly Regex _rxTwo = new(@".get_Item\((\d+)\)", RegexOptions.Compiled);//replaced result: One.Two[1].Three[2].Four
+    private static readonly Regex _rxThree = new(@"\[\d+\]", RegexOptions.Compiled);
+    private static readonly Regex _rxFour = new(@"\[(\d+)\]", RegexOptions.Compiled);
 
-        private static string ToLowerCaseLetter(long n)
+    private static string? ToLowerCaseLetter(long n)
+    {
+        string? val = null;
+        const char c = 'a';
+        while (n >= 0)
         {
-            string val = null;
-            const char c = 'a';
-            while (n >= 0)
-            {
-                val = (char)(c + (n % 26)) + val;
-                n /= 26;
-                n--;
-            }
-
-            return val;
+            val = (char)(c + (n % 26)) + val;
+            n /= 26;
+            n--;
         }
 
-        private static void ThrowIfInvalid<T>(Expression<Func<T, object>> expression)
-        {
-            if (expression == null)
-                throw new ArgumentNullException(nameof(expression), "The supplied expression is null!");
+        return val;
+    }
 
-            if (expression.Body.NodeType == ExpressionType.Parameter)
-                throw new ArgumentException("Cannot generate property path from lambda parameter!");
-        }
+    private static void ThrowIfInvalid<T>(Expression<Func<T, object>> expression)
+    {
+        if (expression == null)
+            throw new ArgumentNullException(nameof(expression), "The supplied expression is null!");
 
-        private static string GetPath<T>(Expression<Func<T, object>> expression)
-        {
-            ThrowIfInvalid(expression);
+        if (expression.Body.NodeType == ExpressionType.Parameter)
+            throw new ArgumentException("Cannot generate property path from lambda parameter!");
+    }
 
-            return rxTwo.Replace(
-                rxOne.Match(expression.ToString()).Value.Substring(1),
-                m => "[" + m.Groups[1].Value + "]");
-        }
+    private static string GetPath<T>(Expression<Func<T, object>> expression)
+    {
+        ThrowIfInvalid(expression);
 
-        internal static string GetPath(string expString)
-        {
-            return
-                rxThree.Replace(
-                    rxTwo.Replace(
-                        rxOne.Match(expString).Value.Substring(1),
-                        m => "[" + m.Groups[1].Value + "]"),
-                    "");
-        }
+        return _rxTwo.Replace(
+            _rxOne.Match(expression.ToString()).Value.Substring(1),
+            m => "[" + m.Groups[1].Value + "]");
+    }
 
-        /// <summary>
-        /// Returns the collection/entity name of a given entity type
-        /// </summary>
-        /// <typeparam name="T">The type of the entity to get the collection name of</typeparam>
-        public static string Collection<T>() where T : IEntity
-        {
-            return EntityCache<T>.CollectionName;
-        }
+    internal static string GetPath(string expString)
+    {
+        return
+            _rxThree.Replace(
+                _rxTwo.Replace(
+                    _rxOne.Match(expString).Value.Substring(1),
+                    m => "[" + m.Groups[1].Value + "]"),
+                "");
+    }
 
-        /// <summary>
-        /// Returns the name of the property for a given expression.
-        /// <para>EX: Authors[0].Books[0].Title > Title</para>
-        /// </summary>
-        /// <param name="expression">x => x.SomeList[0].SomeProp</param>
-        public static string Property<T>(Expression<Func<T, object>> expression)
-        {
-            ThrowIfInvalid(expression);
-            return expression.MemberInfo().Name;
-        }
+    /// <summary>
+    /// Returns the name of the property for a given expression.
+    /// <para>EX: Authors[0].Books[0].Title > Title</para>
+    /// </summary>
+    /// <param name="expression">x => x.SomeList[0].SomeProp</param>
+    public static string Property<T>(Expression<Func<T, object>> expression)
+    {
+        ThrowIfInvalid(expression);
+        return expression.MemberInfo().Name;
+    }
 
-        /// <summary>
-        /// Returns the full dotted path for a given expression.
-        /// <para>EX: Authors[0].Books[0].Title > Authors.Books.Title</para>
-        /// </summary>
-        /// <param name="expression">x => x.SomeList[0].SomeProp</param>
-        public static string Path<T>(Expression<Func<T, object>> expression)
-        {
-            return rxThree.Replace(GetPath(expression), "");
-        }
+    /// <summary>
+    /// Returns the full dotted path for a given expression.
+    /// <para>EX: Authors[0].Books[0].Title > Authors.Books.Title</para>
+    /// </summary>
+    /// <param name="expression">x => x.SomeList[0].SomeProp</param>
+    public static string Path<T>(Expression<Func<T, object>> expression)
+    {
+        return _rxThree.Replace(GetPath(expression), "");
+    }
 
-        /// <summary>
-        /// Returns a path with filtered positional identifiers $[x] for a given expression.
-        /// <para>EX: Authors[0].Name > Authors.$[a].Name</para>
-        /// <para>EX: Authors[1].Age > Authors.$[b].Age</para>
-        /// <para>EX: Authors[2].Books[3].Title > Authors.$[c].Books.$[d].Title</para>
-        /// <para>TIP: Index positions start from [0] which is converted to $[a] and so on.</para>
-        /// </summary>
-        /// <param name="expression">x => x.SomeList[0].SomeProp</param>
-        public static string PosFiltered<T>(Expression<Func<T, object>> expression)
-        {
-            return rxFour.Replace(
-                            GetPath(expression),
-                            m => ".$[" + ToLowerCaseLetter(int.Parse(m.Groups[1].Value)) + "]");
-        }
+    /// <summary>
+    /// Returns a path with filtered positional identifiers $[x] for a given expression.
+    /// <para>EX: Authors[0].Name > Authors.$[a].Name</para>
+    /// <para>EX: Authors[1].Age > Authors.$[b].Age</para>
+    /// <para>EX: Authors[2].Books[3].Title > Authors.$[c].Books.$[d].Title</para>
+    /// <para>TIP: Index positions start from [0] which is converted to $[a] and so on.</para>
+    /// </summary>
+    /// <param name="expression">x => x.SomeList[0].SomeProp</param>
+    public static string PosFiltered<T>(Expression<Func<T, object>> expression)
+    {
+        return _rxFour.Replace(
+                        GetPath(expression),
+                        m => ".$[" + ToLowerCaseLetter(int.Parse(m.Groups[1].Value)) + "]");
+    }
 
-        /// <summary>
-        /// Returns a path with the all positional operator $[] for a given expression.
-        /// <para>EX: Authors[0].Name > Authors.$[].Name</para>
-        /// </summary>
-        /// <param name="expression">x => x.SomeList[0].SomeProp</param>
-        public static string PosAll<T>(Expression<Func<T, object>> expression)
-        {
-            return rxThree.Replace(GetPath(expression), ".$[]");
-        }
+    /// <summary>
+    /// Returns a path with the all positional operator $[] for a given expression.
+    /// <para>EX: Authors[0].Name > Authors.$[].Name</para>
+    /// </summary>
+    /// <param name="expression">x => x.SomeList[0].SomeProp</param>
+    public static string PosAll<T>(Expression<Func<T, object>> expression)
+    {
+        return _rxThree.Replace(GetPath(expression), ".$[]");
+    }
 
-        /// <summary>
-        /// Returns a path with the first positional operator $ for a given expression.
-        /// <para>EX: Authors[0].Name > Authors.$.Name</para>
-        /// </summary>
-        /// <param name="expression">x => x.SomeList[0].SomeProp</param>
-        public static string PosFirst<T>(Expression<Func<T, object>> expression)
-        {
-            return rxThree.Replace(GetPath(expression), ".$");
-        }
+    /// <summary>
+    /// Returns a path with the first positional operator $ for a given expression.
+    /// <para>EX: Authors[0].Name > Authors.$.Name</para>
+    /// </summary>
+    /// <param name="expression">x => x.SomeList[0].SomeProp</param>
+    public static string PosFirst<T>(Expression<Func<T, object>> expression)
+    {
+        return _rxThree.Replace(GetPath(expression), ".$");
+    }
 
-        /// <summary>
-        /// Returns a path without any filtered positional identifier prepended to it.
-        /// <para>EX: b => b.Tags > Tags</para>
-        /// </summary>
-        /// <param name="expression">x => x.SomeProp</param>
-        public static string Elements<T>(Expression<Func<T, object>> expression)
-        {
-            return Path(expression);
-        }
+    /// <summary>
+    /// Returns a path without any filtered positional identifier prepended to it.
+    /// <para>EX: b => b.Tags > Tags</para>
+    /// </summary>
+    /// <param name="expression">x => x.SomeProp</param>
+    public static string Elements<T>(Expression<Func<T, object>> expression)
+    {
+        return Path(expression);
+    }
 
-        /// <summary>
-        /// Returns a path with the filtered positional identifier prepended to the property path.
-        /// <para>EX: 0, x => x.Rating > a.Rating</para>
-        /// <para>EX: 1, x => x.Rating > b.Rating</para>
-        /// <para>TIP: Index positions start from '0' which is converted to 'a' and so on.</para>
-        /// </summary>
-        /// <param name="index">0=a 1=b 2=c 3=d and so on...</param>
-        /// <param name="expression">x => x.SomeProp</param>
-        public static string Elements<T>(int index, Expression<Func<T, object>> expression)
-        {
-            return $"{ToLowerCaseLetter(index)}.{Path(expression)}";
-        }
+    /// <summary>
+    /// Returns a path with the filtered positional identifier prepended to the property path.
+    /// <para>EX: 0, x => x.Rating > a.Rating</para>
+    /// <para>EX: 1, x => x.Rating > b.Rating</para>
+    /// <para>TIP: Index positions start from '0' which is converted to 'a' and so on.</para>
+    /// </summary>
+    /// <param name="index">0=a 1=b 2=c 3=d and so on...</param>
+    /// <param name="expression">x => x.SomeProp</param>
+    public static string Elements<T>(int index, Expression<Func<T, object>> expression)
+    {
+        return $"{ToLowerCaseLetter(index)}.{Path(expression)}";
     }
 }
diff --git a/MongoDB.Entities/Core/SequenceCounter.cs b/MongoDB.Entities/Core/SequenceCounter.cs
index 1331b3e47..53528d9f1 100644
--- a/MongoDB.Entities/Core/SequenceCounter.cs
+++ b/MongoDB.Entities/Core/SequenceCounter.cs
@@ -1,18 +1,14 @@
-using MongoDB.Bson;
-using MongoDB.Bson.Serialization.Attributes;
+namespace MongoDB.Entities;
 
-namespace MongoDB.Entities
+[Collection("[SEQUENCE_COUNTERS]")]
+internal class SequenceCounter : IEntity<string>
 {
-    [Collection("[SEQUENCE_COUNTERS]")]
-    internal class SequenceCounter : IEntity
-    {
-        [BsonId]
-        public string ID { get; set; } = null!;
+    [BsonId]
+    public string ID { get; set; } = null!;
 
-        [BsonRepresentation(BsonType.Int64)]
-        public ulong Count { get; set; }
+    [BsonRepresentation(BsonType.Int64)]
+    public ulong Count { get; set; }
 
-        public string GenerateNewID()
-            => throw new System.NotImplementedException();
-    }
+    public string GenerateNewID()
+        => throw new NotImplementedException();
 }
diff --git a/MongoDB.Entities/Core/Template.cs b/MongoDB.Entities/Core/Template.cs
index f5aed1e45..e3e8373cc 100644
--- a/MongoDB.Entities/Core/Template.cs
+++ b/MongoDB.Entities/Core/Template.cs
@@ -15,7 +15,7 @@ namespace MongoDB.Entities
     /// A helper class to build a JSON command from a string with tag replacement
     /// </summary>
     /// <typeparam name="T">Any type that implements IEntity</typeparam>
-    public class Template<T> : Template<T, T> where T : IEntity
+    public class Template<T> : Template<T, T>
     {
         /// <summary>
         /// Initializes a template with a tagged input string.
@@ -29,7 +29,7 @@ public Template(string template) : base(template) { }
     /// </summary>
     /// <typeparam name="TInput">The input type</typeparam>
     /// <typeparam name="TResult">The output type</typeparam>
-    public class Template<TInput, TResult> : Template where TInput : IEntity
+    public class Template<TInput, TResult> : Template
     {
         /// <summary>
         /// Initializes a template with a tagged input string.
@@ -361,11 +361,11 @@ public void AppendStage(string pipelineStageString)
         /// Gets the collection name of a given entity type and replaces matching tags in the template such as "&lt;EntityName&gt;"
         /// </summary>
         /// <typeparam name="TEntity">The type of entity to get the collection name of</typeparam>
-        public Template Collection<TEntity>() where TEntity : IEntity
+        public Template Collection<TEntity>()
         {
             if (cacheHit) return this;
 
-            return ReplacePath(Prop.Collection<TEntity>());
+            return ReplacePath(EntityCache<TEntity>.Default.CollectionName);
         }
 
         /// <summary>
@@ -393,7 +393,7 @@ public Template Properties<T>(Expression<Func<T, object>> expression)
                 .Cast<MemberExpression>()
                 .Select(e => e.Member.Name);
 
-            if (!props.Any())
+            if (props == null || !props.Any())
                 throw new ArgumentException("Unable to parse any property names from the supplied `new` expression!");
 
             foreach (var p in props)
@@ -426,7 +426,7 @@ public Template Paths<T>(Expression<Func<T, object>> expression)
                 .Arguments
                 .Select(a => Prop.GetPath(a.ToString()));
 
-            if (!paths.Any())
+            if (paths is null || !paths.Any())
                 throw new ArgumentException("Unable to parse any property paths from the supplied `new` expression!");
 
             foreach (var p in paths)
diff --git a/MongoDB.Entities/Core/Transaction.cs b/MongoDB.Entities/Core/Transaction.cs
index 0b78eef09..5f5d421f7 100644
--- a/MongoDB.Entities/Core/Transaction.cs
+++ b/MongoDB.Entities/Core/Transaction.cs
@@ -1,53 +1,55 @@
-using MongoDB.Driver;
-using System;
+namespace MongoDB.Entities;
 
-namespace MongoDB.Entities
+/// <summary>
+/// Represents a transaction used to carry out inter-related write operations.
+/// <para>TIP: Remember to always call .Dispose() after use or enclose in a 'Using' statement.</para>
+/// <para>IMPORTANT: Use the methods on this transaction to perform operations and not the methods on the DB class.</para>
+/// </summary>
+public class Transaction : DBContext, IDisposable
 {
     /// <summary>
-    /// Represents a transaction used to carry out inter-related write operations.
-    /// <para>TIP: Remember to always call .Dispose() after use or enclose in a 'Using' statement.</para>
-    /// <para>IMPORTANT: Use the methods on this transaction to perform operations and not the methods on the DB class.</para>
+    /// Instantiates and begins a transaction.
     /// </summary>
-    public class Transaction : DBContext, IDisposable
+    /// <param name="context"></param>
+    /// <param name="database">The name of the database to use for this transaction. default db is used if not specified</param>
+    /// <param name="options">Client session options for this transaction</param>    
+    public Transaction(MongoServerContext context, string database, ClientSessionOptions? options = null) : base(mongoContext: new(context), database: database)
     {
-        /// <summary>
-        /// Instantiates and begins a transaction.
-        /// </summary>
-        /// <param name="database">The name of the database to use for this transaction. default db is used if not specified</param>
-        /// <param name="options">Client session options for this transaction</param>
-        /// <param name="modifiedBy">An optional ModifiedBy instance. 
-        /// When supplied, all save/update operations performed via this DBContext instance will set the value on entities that has a property of type ModifiedBy. 
-        /// You can inherit from the ModifiedBy class and add your own properties to it. 
-        /// Only one ModifiedBy property is allowed on a single entity type.</param>
-        public Transaction(string database = default, ClientSessionOptions options = null, ModifiedBy modifiedBy = null)
-        {
-            Session = DB.Database(database).Client.StartSession(options);
-            Session.StartTransaction();
-            ModifiedBy = modifiedBy;
-        }
+        MongoServerContext.Transaction(options);
+    }
+
+    /// <summary>
+    /// Instantiates and begins a transaction.
+    /// </summary>
+    /// <param name="context"></param>
+    /// <param name="database">The name of the database to use for this transaction. default db is used if not specified</param>
+    /// <param name="options">Client session options for this transaction</param>    
+    public Transaction(MongoServerContext context, IMongoDatabase database, ClientSessionOptions? options = null) : base(mongoContext: new(context), database: database)
+    {
+        MongoServerContext.Transaction(options);
+    }
 
-        #region IDisposable Support
+    #region IDisposable Support
 
-        private bool disposedValue;
+    private bool _disposedValue;
 
-        protected virtual void Dispose(bool disposing)
+    protected virtual void Dispose(bool disposing)
+    {
+        if (!_disposedValue)
         {
-            if (!disposedValue)
+            if (disposing)
             {
-                if (disposing)
-                {
-                    Session.Dispose();
-                }
-
-                disposedValue = true;
+                MongoServerContext.Dispose();
             }
-        }
 
-        public void Dispose()
-        {
-            Dispose(true);
+            _disposedValue = true;
         }
+    }
 
-        #endregion        
+    public void Dispose()
+    {
+        Dispose(true);
     }
+
+    #endregion
 }
diff --git a/MongoDB.Entities/Core/Watcher.cs b/MongoDB.Entities/Core/Watcher.cs
index 42397fccf..da17ce42f 100644
--- a/MongoDB.Entities/Core/Watcher.cs
+++ b/MongoDB.Entities/Core/Watcher.cs
@@ -1,293 +1,283 @@
-using MongoDB.Bson;
-using MongoDB.Bson.Serialization;
-using MongoDB.Driver;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Linq.Expressions;
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace MongoDB.Entities
+namespace MongoDB.Entities;
+
+public delegate Task AsyncEventHandler<TEventArgs>(TEventArgs args);
+public static class AsyncEventHandlerExtensions
 {
-    public delegate Task AsyncEventHandler<TEventArgs>(TEventArgs args);
-    public static class AsyncEventHandlerExtensions
-    {
-        public static IEnumerable<AsyncEventHandler<TEventArgs>> GetHandlers<TEventArgs>(this AsyncEventHandler<TEventArgs> handler)
-            => handler.GetInvocationList().Cast<AsyncEventHandler<TEventArgs>>();
+    public static IEnumerable<AsyncEventHandler<TEventArgs>> GetHandlers<TEventArgs>(this AsyncEventHandler<TEventArgs> handler)
+        => handler.GetInvocationList().Cast<AsyncEventHandler<TEventArgs>>();
+
+    public static Task InvokeAllAsync<TEventArgs>(this AsyncEventHandler<TEventArgs> handler, TEventArgs args)
+        => Task.WhenAll(handler.GetHandlers().Select(h => h(args)));
+}
+
+/// <summary>
+/// Watcher for subscribing to mongodb change streams.
+/// </summary>
+/// <typeparam name="T">The type of entity</typeparam>
+public class Watcher<T>
+{
+    /// <summary>
+    /// This event is fired when the desired types of events have occured. Will have a list of 'entities' that was received as input.
+    /// </summary>
+    public event Action<IEnumerable<T>>? OnChanges;
+
+    /// <summary>
+    /// This event is fired when the desired types of events have occured. Will have a list of 'entities' that was received as input.
+    /// </summary>
+    public event AsyncEventHandler<IEnumerable<T>>? OnChangesAsync;
+
+    /// <summary>
+    /// This event is fired when the desired types of events have occured. Will have a list of 'ChangeStreamDocuments' that was received as input.
+    /// </summary>
+    public event Action<IEnumerable<ChangeStreamDocument<T>>>? OnChangesCSD;
+
+    /// <summary>
+    /// This event is fired when the desired types of events have occured. Will have a list of 'ChangeStreamDocuments' that was received as input.
+    /// </summary>
+    public event AsyncEventHandler<IEnumerable<ChangeStreamDocument<T>>>? OnChangesCSDAsync;
+
+    /// <summary>
+    /// This event is fired when an exception is thrown in the change-stream.
+    /// </summary>
+    public event Action<Exception>? OnError;
+
+    /// <summary>
+    /// This event is fired when the internal cursor get closed due to an 'invalidate' event or cancellation is requested via the cancellation token.
+    /// </summary>
+    public event Action? OnStop;
+
+    /// <summary>
+    /// The name of this watcher instance
+    /// </summary>
+    public string Name { get; }
+
+    /// <summary>
+    /// Indicates whether this watcher has already been initialized or not.
+    /// </summary>
+    public bool IsInitialized { get => _initialized; }
+
+    /// <summary>
+    /// Returns true if watching can be restarted if it was stopped due to an error or invalidate event.
+    /// Will always return false after cancellation is requested via the cancellation token.
+    /// </summary>
+    public bool CanRestart { get => !_cancelToken.IsCancellationRequested; }
 
-        public static Task InvokeAllAsync<TEventArgs>(this AsyncEventHandler<TEventArgs> handler, TEventArgs args)
-            => Task.WhenAll(handler.GetHandlers().Select(h => h(args)));
+    /// <summary>
+    /// The last resume token received from mongodb server. Can be used to resume watching with .StartWithToken() method.
+    /// </summary>
+    public BsonDocument? ResumeToken => _options?.StartAfter;
+
+    private PipelineDefinition<ChangeStreamDocument<T>, ChangeStreamDocument<T>>? _pipeline;
+    private ChangeStreamOptions? _options;
+    private bool _resume;
+    private CancellationToken _cancelToken;
+    private bool _initialized;
+    private readonly IMongoCollection<T> _collection;
+    internal Watcher(string name, IMongoCollection<T> collection)
+    {
+        Name = name;
+        _collection = collection;
     }
 
     /// <summary>
-    /// Watcher for subscribing to mongodb change streams.
+    /// Starts the watcher instance with the supplied parameters
+    /// </summary>
+    /// <param name="eventTypes">Type of event to watch for. Specify multiple like: EventType.Created | EventType.Updated | EventType.Deleted</param>
+    /// <param name="filter">x => x.FullDocument.Prop1 == "SomeValue"</param>
+    /// <param name="batchSize">The max number of entities to receive for a single event occurence</param>
+    /// <param name="onlyGetIDs">Set to true if you don't want the complete entity details. All properties except the ID will then be null.</param>
+    /// <param name="autoResume">Set to false if you'd like to skip the changes that happened while the watching was stopped. This will also make you unable to retrieve a ResumeToken.</param>
+    /// <param name="cancellation">A cancellation token for ending the watching/change stream</param>
+    public void Start(
+        EventType eventTypes,
+        Expression<Func<ChangeStreamDocument<T>, bool>>? filter = null,
+        int batchSize = 25,
+        bool onlyGetIDs = false,
+        bool autoResume = true,
+        CancellationToken cancellation = default)
+    => Init(null, eventTypes, filter, null, batchSize, onlyGetIDs, autoResume, cancellation);
+
+    /// <summary>
+    /// Starts the watcher instance with the supplied parameters. Supports projection.
+    /// </summary>
+    /// <param name="eventTypes">Type of event to watch for. Specify multiple like: EventType.Created | EventType.Updated | EventType.Deleted</param>
+    /// <param name="projection">A projection expression for the entity</param>
+    /// <param name="filter">x => x.FullDocument.Prop1 == "SomeValue"</param>
+    /// <param name="batchSize">The max number of entities to receive for a single event occurence</param>
+    /// <param name="autoResume">Set to false if you'd like to skip the changes that happened while the watching was stopped. This will also make you unable to retrieve a ResumeToken.</param>
+    /// <param name="cancellation">A cancellation token for ending the watching/change stream</param>
+    public void Start(
+        EventType eventTypes,
+        Expression<Func<T, T>>? projection,
+        Expression<Func<ChangeStreamDocument<T>, bool>>? filter = null,
+        int batchSize = 25,
+        bool autoResume = true,
+        CancellationToken cancellation = default)
+    => Init(null, eventTypes, filter, projection, batchSize, false, autoResume, cancellation);
+
+    /// <summary>
+    /// Starts the watcher instance with the supplied parameters
+    /// </summary>
+    /// <param name="eventTypes">Type of event to watch for. Specify multiple like: EventType.Created | EventType.Updated | EventType.Deleted</param>
+    /// <param name="filter">b => b.Eq(d => d.FullDocument.Prop1, "value")</param>
+    /// <param name="batchSize">The max number of entities to receive for a single event occurence</param>
+    /// <param name="onlyGetIDs">Set to true if you don't want the complete entity details. All properties except the ID will then be null.</param>
+    /// <param name="autoResume">Set to false if you'd like to skip the changes that happened while the watching was stopped. This will also make you unable to retrieve a ResumeToken.</param>
+    /// <param name="cancellation">A cancellation token for ending the watching/change stream</param>
+    public void Start(
+        EventType eventTypes,
+        Func<FilterDefinitionBuilder<ChangeStreamDocument<T>>, FilterDefinition<ChangeStreamDocument<T>>> filter,
+        int batchSize = 25,
+        bool onlyGetIDs = false,
+        bool autoResume = true,
+        CancellationToken cancellation = default)
+    => Init(null, eventTypes, filter(Builders<ChangeStreamDocument<T>>.Filter), null, batchSize, onlyGetIDs, autoResume, cancellation);
+
+    /// <summary>
+    /// Starts the watcher instance with the supplied parameters. Supports projection.
+    /// </summary>
+    /// <param name="eventTypes">Type of event to watch for. Specify multiple like: EventType.Created | EventType.Updated | EventType.Deleted</param>
+    /// <param name="projection">A projection expression for the entity</param>
+    /// <param name="filter">b => b.Eq(d => d.FullDocument.Prop1, "value")</param>
+    /// <param name="batchSize">The max number of entities to receive for a single event occurence</param>
+    /// <param name="autoResume">Set to false if you'd like to skip the changes that happened while the watching was stopped. This will also make you unable to retrieve a ResumeToken.</param>
+    /// <param name="cancellation">A cancellation token for ending the watching/change stream</param>
+    public void Start(
+        EventType eventTypes,
+        Expression<Func<T, T>> projection,
+        Func<FilterDefinitionBuilder<ChangeStreamDocument<T>>, FilterDefinition<ChangeStreamDocument<T>>> filter,
+        int batchSize = 25,
+        bool autoResume = true,
+        CancellationToken cancellation = default)
+    => Init(null, eventTypes, filter(Builders<ChangeStreamDocument<T>>.Filter), projection, batchSize, false, autoResume, cancellation);
+
+    /// <summary>
+    /// Starts the watcher instance with the supplied configuration
+    /// </summary>
+    /// <param name="resumeToken">A resume token to start receiving changes after some point back in time</param>
+    /// <param name="eventTypes">Type of event to watch for. Specify multiple like: EventType.Created | EventType.Updated | EventType.Deleted</param>
+    /// <param name="filter">x => x.FullDocument.Prop1 == "SomeValue"</param>
+    /// <param name="batchSize">The max number of entities to receive for a single event occurence</param>
+    /// <param name="onlyGetIDs">Set to true if you don't want the complete entity details. All properties except the ID will then be null.</param>
+    /// <param name="cancellation">A cancellation token for ending the watching/change stream</param>
+    public void StartWithToken(
+        BsonDocument resumeToken,
+        EventType eventTypes,
+        Expression<Func<ChangeStreamDocument<T>, bool>>? filter = null,
+        int batchSize = 25,
+        bool onlyGetIDs = false,
+        CancellationToken cancellation = default)
+    => Init(resumeToken, eventTypes, filter, null, batchSize, onlyGetIDs, true, cancellation);
+
+    /// <summary>
+    /// Starts the watcher instance with the supplied configuration. Supports projection.
+    /// </summary>
+    /// <param name="resumeToken">A resume token to start receiving changes after some point back in time</param>
+    /// <param name="eventTypes">Type of event to watch for. Specify multiple like: EventType.Created | EventType.Updated | EventType.Deleted</param>
+    /// <param name="projection">A projection expression for the entity</param>
+    /// <param name="filter">x => x.FullDocument.Prop1 == "SomeValue"</param>
+    /// <param name="batchSize">The max number of entities to receive for a single event occurence</param>
+    /// <param name="cancellation">A cancellation token for ending the watching/change stream</param>
+    public void StartWithToken(
+        BsonDocument resumeToken,
+        EventType eventTypes,
+        Expression<Func<T, T>> projection,
+        Expression<Func<ChangeStreamDocument<T>, bool>>? filter = null,
+        int batchSize = 25,
+        CancellationToken cancellation = default)
+    => Init(resumeToken, eventTypes, filter, projection, batchSize, false, true, cancellation);
+
+    /// <summary>
+    /// Starts the watcher instance with the supplied configuration
+    /// </summary>
+    /// <param name="resumeToken">A resume token to start receiving changes after some point back in time</param>
+    /// <param name="eventTypes">Type of event to watch for. Specify multiple like: EventType.Created | EventType.Updated | EventType.Deleted</param>
+    /// <param name="filter">b => b.Eq(d => d.FullDocument.Prop1, "value")</param>
+    /// <param name="batchSize">The max number of entities to receive for a single event occurence</param>
+    /// <param name="onlyGetIDs">Set to true if you don't want the complete entity details. All properties except the ID will then be null.</param>
+    /// <param name="cancellation">A cancellation token for ending the watching/change stream</param>
+    public void StartWithToken(
+        BsonDocument resumeToken,
+        EventType eventTypes,
+        Func<FilterDefinitionBuilder<ChangeStreamDocument<T>>, FilterDefinition<ChangeStreamDocument<T>>> filter,
+        int batchSize = 25,
+        bool onlyGetIDs = false,
+        CancellationToken cancellation = default)
+    => Init(resumeToken, eventTypes, filter(Builders<ChangeStreamDocument<T>>.Filter), null, batchSize, onlyGetIDs, true, cancellation);
+
+    /// <summary>
+    /// Starts the watcher instance with the supplied configuration. Supports projection.
     /// </summary>
-    /// <typeparam name="T">The type of entity</typeparam>
-    public class Watcher<T> where T : IEntity
+    /// <param name="resumeToken">A resume token to start receiving changes after some point back in time</param>
+    /// <param name="eventTypes">Type of event to watch for. Specify multiple like: EventType.Created | EventType.Updated | EventType.Deleted</param>
+    /// <param name="projection">A projection expression for the entity</param>
+    /// <param name="filter">b => b.Eq(d => d.FullDocument.Prop1, "value")</param>
+    /// <param name="batchSize">The max number of entities to receive for a single event occurence</param>
+    /// <param name="cancellation">A cancellation token for ending the watching/change stream</param>
+    public void StartWithToken(
+        BsonDocument resumeToken,
+        EventType eventTypes,
+        Expression<Func<T, T>> projection,
+        Func<FilterDefinitionBuilder<ChangeStreamDocument<T>>, FilterDefinition<ChangeStreamDocument<T>>> filter,
+        int batchSize = 25,
+        CancellationToken cancellation = default)
+    => Init(resumeToken, eventTypes, filter(Builders<ChangeStreamDocument<T>>.Filter), projection, batchSize, false, true, cancellation);
+
+    private void Init(
+        BsonDocument? resumeToken,
+        EventType eventTypes,
+        FilterDefinition<ChangeStreamDocument<T>> filter,
+        Expression<Func<T, T>>? projection,
+        int batchSize,
+        bool onlyGetIDs,
+        bool autoResume,
+        CancellationToken cancellation)
     {
-        /// <summary>
-        /// This event is fired when the desired types of events have occured. Will have a list of 'entities' that was received as input.
-        /// </summary>
-        public event Action<IEnumerable<T>>? OnChanges;
-
-        /// <summary>
-        /// This event is fired when the desired types of events have occured. Will have a list of 'entities' that was received as input.
-        /// </summary>
-        public event AsyncEventHandler<IEnumerable<T>>? OnChangesAsync;
-
-        /// <summary>
-        /// This event is fired when the desired types of events have occured. Will have a list of 'ChangeStreamDocuments' that was received as input.
-        /// </summary>
-        public event Action<IEnumerable<ChangeStreamDocument<T>>>? OnChangesCSD;
-
-        /// <summary>
-        /// This event is fired when the desired types of events have occured. Will have a list of 'ChangeStreamDocuments' that was received as input.
-        /// </summary>
-        public event AsyncEventHandler<IEnumerable<ChangeStreamDocument<T>>>? OnChangesCSDAsync;
-
-        /// <summary>
-        /// This event is fired when an exception is thrown in the change-stream.
-        /// </summary>
-        public event Action<Exception>? OnError;
-
-        /// <summary>
-        /// This event is fired when the internal cursor get closed due to an 'invalidate' event or cancellation is requested via the cancellation token.
-        /// </summary>
-        public event Action? OnStop;
-
-        /// <summary>
-        /// The name of this watcher instance
-        /// </summary>
-        public string Name { get; }
-
-        /// <summary>
-        /// Indicates whether this watcher has already been initialized or not.
-        /// </summary>
-        public bool IsInitialized { get => _initialized; }
-
-        /// <summary>
-        /// Returns true if watching can be restarted if it was stopped due to an error or invalidate event.
-        /// Will always return false after cancellation is requested via the cancellation token.
-        /// </summary>
-        public bool CanRestart { get => !_cancelToken.IsCancellationRequested; }
-
-        /// <summary>
-        /// The last resume token received from mongodb server. Can be used to resume watching with .StartWithToken() method.
-        /// </summary>
-        public BsonDocument? ResumeToken => _options?.StartAfter;
-
-        private PipelineDefinition<ChangeStreamDocument<T>, ChangeStreamDocument<T>>? _pipeline;
-        private ChangeStreamOptions? _options;
-        private bool _resume;
-        private CancellationToken _cancelToken;
-        private bool _initialized;
-        private readonly IMongoCollection<T> _collection;
-        internal Watcher(string name, DBContext context, IMongoCollection<T> collection)
-        {
-            Name = name;
-            _collection = collection;
-        }
+        if (_initialized)
+            throw new InvalidOperationException("This watcher has already been initialized!");
 
-        /// <summary>
-        /// Starts the watcher instance with the supplied parameters
-        /// </summary>
-        /// <param name="eventTypes">Type of event to watch for. Specify multiple like: EventType.Created | EventType.Updated | EventType.Deleted</param>
-        /// <param name="filter">x => x.FullDocument.Prop1 == "SomeValue"</param>
-        /// <param name="batchSize">The max number of entities to receive for a single event occurence</param>
-        /// <param name="onlyGetIDs">Set to true if you don't want the complete entity details. All properties except the ID will then be null.</param>
-        /// <param name="autoResume">Set to false if you'd like to skip the changes that happened while the watching was stopped. This will also make you unable to retrieve a ResumeToken.</param>
-        /// <param name="cancellation">A cancellation token for ending the watching/change stream</param>
-        public void Start(
-            EventType eventTypes,
-            Expression<Func<ChangeStreamDocument<T>, bool>>? filter = null,
-            int batchSize = 25,
-            bool onlyGetIDs = false,
-            bool autoResume = true,
-            CancellationToken cancellation = default)
-        => Init(null, eventTypes, filter, null, batchSize, onlyGetIDs, autoResume, cancellation);
-
-        /// <summary>
-        /// Starts the watcher instance with the supplied parameters. Supports projection.
-        /// </summary>
-        /// <param name="eventTypes">Type of event to watch for. Specify multiple like: EventType.Created | EventType.Updated | EventType.Deleted</param>
-        /// <param name="projection">A projection expression for the entity</param>
-        /// <param name="filter">x => x.FullDocument.Prop1 == "SomeValue"</param>
-        /// <param name="batchSize">The max number of entities to receive for a single event occurence</param>
-        /// <param name="autoResume">Set to false if you'd like to skip the changes that happened while the watching was stopped. This will also make you unable to retrieve a ResumeToken.</param>
-        /// <param name="cancellation">A cancellation token for ending the watching/change stream</param>
-        public void Start(
-            EventType eventTypes,
-            Expression<Func<T, T>>? projection,
-            Expression<Func<ChangeStreamDocument<T>, bool>>? filter = null,
-            int batchSize = 25,
-            bool autoResume = true,
-            CancellationToken cancellation = default)
-        => Init(null, eventTypes, filter, projection, batchSize, false, autoResume, cancellation);
-
-        /// <summary>
-        /// Starts the watcher instance with the supplied parameters
-        /// </summary>
-        /// <param name="eventTypes">Type of event to watch for. Specify multiple like: EventType.Created | EventType.Updated | EventType.Deleted</param>
-        /// <param name="filter">b => b.Eq(d => d.FullDocument.Prop1, "value")</param>
-        /// <param name="batchSize">The max number of entities to receive for a single event occurence</param>
-        /// <param name="onlyGetIDs">Set to true if you don't want the complete entity details. All properties except the ID will then be null.</param>
-        /// <param name="autoResume">Set to false if you'd like to skip the changes that happened while the watching was stopped. This will also make you unable to retrieve a ResumeToken.</param>
-        /// <param name="cancellation">A cancellation token for ending the watching/change stream</param>
-        public void Start(
-            EventType eventTypes,
-            Func<FilterDefinitionBuilder<ChangeStreamDocument<T>>, FilterDefinition<ChangeStreamDocument<T>>> filter,
-            int batchSize = 25,
-            bool onlyGetIDs = false,
-            bool autoResume = true,
-            CancellationToken cancellation = default)
-        => Init(null, eventTypes, filter(Builders<ChangeStreamDocument<T>>.Filter), null, batchSize, onlyGetIDs, autoResume, cancellation);
-
-        /// <summary>
-        /// Starts the watcher instance with the supplied parameters. Supports projection.
-        /// </summary>
-        /// <param name="eventTypes">Type of event to watch for. Specify multiple like: EventType.Created | EventType.Updated | EventType.Deleted</param>
-        /// <param name="projection">A projection expression for the entity</param>
-        /// <param name="filter">b => b.Eq(d => d.FullDocument.Prop1, "value")</param>
-        /// <param name="batchSize">The max number of entities to receive for a single event occurence</param>
-        /// <param name="autoResume">Set to false if you'd like to skip the changes that happened while the watching was stopped. This will also make you unable to retrieve a ResumeToken.</param>
-        /// <param name="cancellation">A cancellation token for ending the watching/change stream</param>
-        public void Start(
-            EventType eventTypes,
-            Expression<Func<T, T>> projection,
-            Func<FilterDefinitionBuilder<ChangeStreamDocument<T>>, FilterDefinition<ChangeStreamDocument<T>>> filter,
-            int batchSize = 25,
-            bool autoResume = true,
-            CancellationToken cancellation = default)
-        => Init(null, eventTypes, filter(Builders<ChangeStreamDocument<T>>.Filter), projection, batchSize, false, autoResume, cancellation);
-
-        /// <summary>
-        /// Starts the watcher instance with the supplied configuration
-        /// </summary>
-        /// <param name="resumeToken">A resume token to start receiving changes after some point back in time</param>
-        /// <param name="eventTypes">Type of event to watch for. Specify multiple like: EventType.Created | EventType.Updated | EventType.Deleted</param>
-        /// <param name="filter">x => x.FullDocument.Prop1 == "SomeValue"</param>
-        /// <param name="batchSize">The max number of entities to receive for a single event occurence</param>
-        /// <param name="onlyGetIDs">Set to true if you don't want the complete entity details. All properties except the ID will then be null.</param>
-        /// <param name="cancellation">A cancellation token for ending the watching/change stream</param>
-        public void StartWithToken(
-            BsonDocument resumeToken,
-            EventType eventTypes,
-            Expression<Func<ChangeStreamDocument<T>, bool>>? filter = null,
-            int batchSize = 25,
-            bool onlyGetIDs = false,
-            CancellationToken cancellation = default)
-        => Init(resumeToken, eventTypes, filter, null, batchSize, onlyGetIDs, true, cancellation);
-
-        /// <summary>
-        /// Starts the watcher instance with the supplied configuration. Supports projection.
-        /// </summary>
-        /// <param name="resumeToken">A resume token to start receiving changes after some point back in time</param>
-        /// <param name="eventTypes">Type of event to watch for. Specify multiple like: EventType.Created | EventType.Updated | EventType.Deleted</param>
-        /// <param name="projection">A projection expression for the entity</param>
-        /// <param name="filter">x => x.FullDocument.Prop1 == "SomeValue"</param>
-        /// <param name="batchSize">The max number of entities to receive for a single event occurence</param>
-        /// <param name="cancellation">A cancellation token for ending the watching/change stream</param>
-        public void StartWithToken(
-            BsonDocument resumeToken,
-            EventType eventTypes,
-            Expression<Func<T, T>> projection,
-            Expression<Func<ChangeStreamDocument<T>, bool>>? filter = null,
-            int batchSize = 25,
-            CancellationToken cancellation = default)
-        => Init(resumeToken, eventTypes, filter, projection, batchSize, false, true, cancellation);
-
-        /// <summary>
-        /// Starts the watcher instance with the supplied configuration
-        /// </summary>
-        /// <param name="resumeToken">A resume token to start receiving changes after some point back in time</param>
-        /// <param name="eventTypes">Type of event to watch for. Specify multiple like: EventType.Created | EventType.Updated | EventType.Deleted</param>
-        /// <param name="filter">b => b.Eq(d => d.FullDocument.Prop1, "value")</param>
-        /// <param name="batchSize">The max number of entities to receive for a single event occurence</param>
-        /// <param name="onlyGetIDs">Set to true if you don't want the complete entity details. All properties except the ID will then be null.</param>
-        /// <param name="cancellation">A cancellation token for ending the watching/change stream</param>
-        public void StartWithToken(
-            BsonDocument resumeToken,
-            EventType eventTypes,
-            Func<FilterDefinitionBuilder<ChangeStreamDocument<T>>, FilterDefinition<ChangeStreamDocument<T>>> filter,
-            int batchSize = 25,
-            bool onlyGetIDs = false,
-            CancellationToken cancellation = default)
-        => Init(resumeToken, eventTypes, filter(Builders<ChangeStreamDocument<T>>.Filter), null, batchSize, onlyGetIDs, true, cancellation);
-
-        /// <summary>
-        /// Starts the watcher instance with the supplied configuration. Supports projection.
-        /// </summary>
-        /// <param name="resumeToken">A resume token to start receiving changes after some point back in time</param>
-        /// <param name="eventTypes">Type of event to watch for. Specify multiple like: EventType.Created | EventType.Updated | EventType.Deleted</param>
-        /// <param name="projection">A projection expression for the entity</param>
-        /// <param name="filter">b => b.Eq(d => d.FullDocument.Prop1, "value")</param>
-        /// <param name="batchSize">The max number of entities to receive for a single event occurence</param>
-        /// <param name="cancellation">A cancellation token for ending the watching/change stream</param>
-        public void StartWithToken(
-            BsonDocument resumeToken,
-            EventType eventTypes,
-            Expression<Func<T, T>> projection,
-            Func<FilterDefinitionBuilder<ChangeStreamDocument<T>>, FilterDefinition<ChangeStreamDocument<T>>> filter,
-            int batchSize = 25,
-            CancellationToken cancellation = default)
-        => Init(resumeToken, eventTypes, filter(Builders<ChangeStreamDocument<T>>.Filter), projection, batchSize, false, true, cancellation);
-
-        private void Init(
-            BsonDocument? resumeToken,
-            EventType eventTypes,
-            FilterDefinition<ChangeStreamDocument<T>> filter,
-            Expression<Func<T, T>>? projection,
-            int batchSize,
-            bool onlyGetIDs,
-            bool autoResume,
-            CancellationToken cancellation)
-        {
-            if (_initialized)
-                throw new InvalidOperationException("This watcher has already been initialized!");
+        _resume = autoResume;
+        _cancelToken = cancellation;
 
-            _resume = autoResume;
-            _cancelToken = cancellation;
+        var ops = new List<ChangeStreamOperationType>(3) { ChangeStreamOperationType.Invalidate };
 
-            var ops = new List<ChangeStreamOperationType>(3) { ChangeStreamOperationType.Invalidate };
+        if ((eventTypes & EventType.Created) != 0)
+            ops.Add(ChangeStreamOperationType.Insert);
 
-            if ((eventTypes & EventType.Created) != 0)
-                ops.Add(ChangeStreamOperationType.Insert);
+        if ((eventTypes & EventType.Updated) != 0)
+        {
+            ops.Add(ChangeStreamOperationType.Update);
+            ops.Add(ChangeStreamOperationType.Replace);
+        }
 
-            if ((eventTypes & EventType.Updated) != 0)
+        if ((eventTypes & EventType.Deleted) != 0)
+            ops.Add(ChangeStreamOperationType.Delete);
+
+        if (ops.Contains(ChangeStreamOperationType.Delete))
+        {
+            if (filter != null)
             {
-                ops.Add(ChangeStreamOperationType.Update);
-                ops.Add(ChangeStreamOperationType.Replace);
+                throw new ArgumentException(
+                "Filtering is not supported when watching for deletions " +
+                "as the entity data no longer exists in the db " +
+                "at the time of receiving the event.");
             }
 
-            if ((eventTypes & EventType.Deleted) != 0)
-                ops.Add(ChangeStreamOperationType.Delete);
-
-            if (ops.Contains(ChangeStreamOperationType.Delete))
+            if (projection != null)
             {
-                if (filter != null)
-                {
-                    throw new ArgumentException(
-                    "Filtering is not supported when watching for deletions " +
-                    "as the entity data no longer exists in the db " +
-                    "at the time of receiving the event.");
-                }
-
-                if (projection != null)
-                {
-                    throw new ArgumentException(
-                    "Projecting is not supported when watching for deletions " +
-                    "as the entity data no longer exists in the db " +
-                    "at the time of receiving the event.");
-                }
+                throw new ArgumentException(
+                "Projecting is not supported when watching for deletions " +
+                "as the entity data no longer exists in the db " +
+                "at the time of receiving the event.");
             }
+        }
 
-            var filters = Builders<ChangeStreamDocument<T>>.Filter.Where(x => ops.Contains(x.OperationType));
+        var filters = Builders<ChangeStreamDocument<T>>.Filter.Where(x => ops.Contains(x.OperationType));
 
-            if (filter != null)
-                filters &= filter;
+        if (filter != null)
+            filters &= filter;
 
-            var stages = new List<IPipelineStageDefinition>(3) {
+        var stages = new List<IPipelineStageDefinition>(3) {
                 PipelineStageDefinitionBuilder.Match(filters),
                 PipelineStageDefinitionBuilder.Project<ChangeStreamDocument<T>,ChangeStreamDocument<T>>(@"
                 {
@@ -299,175 +289,174 @@ private void Init(
                 }")
             };
 
-            if (projection != null)
-                stages.Add(PipelineStageDefinitionBuilder.Project(BuildProjection(projection)));
-
-            _pipeline = stages;
+        if (projection != null)
+            stages.Add(PipelineStageDefinitionBuilder.Project(BuildProjection(projection)));
 
-            _options = new ChangeStreamOptions
-            {
-                StartAfter = resumeToken,
-                BatchSize = batchSize,
-                FullDocument = onlyGetIDs ? ChangeStreamFullDocumentOption.Default : ChangeStreamFullDocumentOption.UpdateLookup,
-                MaxAwaitTime = TimeSpan.FromSeconds(10)
-            };
+        _pipeline = stages;
 
-            _initialized = true;
+        _options = new ChangeStreamOptions
+        {
+            StartAfter = resumeToken,
+            BatchSize = batchSize,
+            FullDocument = onlyGetIDs ? ChangeStreamFullDocumentOption.Default : ChangeStreamFullDocumentOption.UpdateLookup,
+            MaxAwaitTime = TimeSpan.FromSeconds(10)
+        };
 
-            StartWatching();
-        }
+        _initialized = true;
 
-        private static ProjectionDefinition<ChangeStreamDocument<T>, ChangeStreamDocument<T>> BuildProjection(Expression<Func<T, T>> projection)
-        {
-            var rendered = Builders<T>.Projection
-                .Expression(projection)
-                .Render(BsonSerializer.SerializerRegistry.GetSerializer<T>(),
-                        BsonSerializer.SerializerRegistry);
+        StartWatching();
+    }
 
-            BsonDocument doc = new()
-            {
-                { "_id", 1 },
-                { "operationType", 1 },
-                { "documentKey", 1 },
-                { "updateDescription", 1 },
-                { "fullDocument._id", 1 }
-            };
+    private static ProjectionDefinition<ChangeStreamDocument<T>, ChangeStreamDocument<T>> BuildProjection(Expression<Func<T, T>> projection)
+    {
+        var rendered = Builders<T>.Projection
+            .Expression(projection)
+            .Render(BsonSerializer.SerializerRegistry.GetSerializer<T>(),
+                    BsonSerializer.SerializerRegistry);
 
-            foreach (var element in rendered.Document.Elements)
+        BsonDocument doc = new()
+        {
+            { "_id", 1 },
+            { "operationType", 1 },
+            { "documentKey", 1 },
+            { "updateDescription", 1 },
+            { "fullDocument._id", 1 }
+        };
+
+        foreach (var element in rendered.Document.Elements)
+        {
+            if (element.Name != "_id")
             {
-                if (element.Name != "_id")
-                {
-                    doc["fullDocument." + element.Name] = element.Value;
-                }
+                doc["fullDocument." + element.Name] = element.Value;
             }
-
-            return doc;
         }
 
-        /// <summary>
-        /// If the watcher stopped due to an error or invalidate event, you can try to restart the watching again with this method.
-        /// </summary>
-        /// <param name="resumeToken">An optional resume token to restart watching with</param>
-        public void ReStart(BsonDocument? resumeToken = null)
+        return doc;
+    }
+
+    /// <summary>
+    /// If the watcher stopped due to an error or invalidate event, you can try to restart the watching again with this method.
+    /// </summary>
+    /// <param name="resumeToken">An optional resume token to restart watching with</param>
+    public void ReStart(BsonDocument? resumeToken = null)
+    {
+        if (!CanRestart)
         {
-            if (!CanRestart)
-            {
-                throw new InvalidOperationException(
-                                    "This watcher has been aborted/cancelled. " +
-                                    "The subscribers have already been purged. " +
-                                    "Please instantiate a new watcher and subscribe to the events again.");
-            }
+            throw new InvalidOperationException(
+                                "This watcher has been aborted/cancelled. " +
+                                "The subscribers have already been purged. " +
+                                "Please instantiate a new watcher and subscribe to the events again.");
+        }
 
-            if (!_initialized)
-                throw new InvalidOperationException("This watcher was never started. Please use .Start() first!");
+        if (!_initialized)
+            throw new InvalidOperationException("This watcher was never started. Please use .Start() first!");
 
-            if (_cancelToken.IsCancellationRequested)
-                throw new InvalidOperationException("This watcher cannot be restarted as it has been aborted/cancelled!");
+        if (_cancelToken.IsCancellationRequested)
+            throw new InvalidOperationException("This watcher cannot be restarted as it has been aborted/cancelled!");
 
-            if (resumeToken != null && _options is not null)
-                _options.StartAfter = resumeToken;
+        if (resumeToken != null && _options is not null)
+            _options.StartAfter = resumeToken;
 
-            StartWatching();
-        }
+        StartWatching();
+    }
 
-        private void StartWatching()
-        {
-            //note  : don't use Task.Factory.StartNew with long running option
-            //reason: http://blog.i3arnon.com/2015/07/02/task-run-long-running/
-            //        StartNew creates an unnecessary dedicated thread which gets released upon reaching first await.
-            //        continuations will be run on differnt threadpool threads upon re-entry.
-            //        i.e. long running thread creation is useless/wasteful for async delegates.
+    private void StartWatching()
+    {
+        //note  : don't use Task.Factory.StartNew with long running option
+        //reason: http://blog.i3arnon.com/2015/07/02/task-run-long-running/
+        //        StartNew creates an unnecessary dedicated thread which gets released upon reaching first await.
+        //        continuations will be run on differnt threadpool threads upon re-entry.
+        //        i.e. long running thread creation is useless/wasteful for async delegates.
 
 
-            _ = IterateCursorAsync();
-            async Task IterateCursorAsync()
+        _ = IterateCursorAsync();
+        async Task IterateCursorAsync()
+        {
+            try
             {
-                try
-                {
 
-                    using var cursor = await _collection.WatchAsync(_pipeline, _options, _cancelToken).ConfigureAwait(false);
-                    while (!_cancelToken.IsCancellationRequested && await cursor.MoveNextAsync(_cancelToken).ConfigureAwait(false))
+                using var cursor = await _collection.WatchAsync(_pipeline, _options, _cancelToken).ConfigureAwait(false);
+                while (!_cancelToken.IsCancellationRequested && await cursor.MoveNextAsync(_cancelToken).ConfigureAwait(false))
+                {
+                    if (cursor.Current.Any())
                     {
-                        if (cursor.Current.Any())
+                        if (_resume && _options is not null)
+                            _options.StartAfter = cursor.Current.Last().ResumeToken;
+
+                        if (OnChangesAsync != null)
                         {
-                            if (_resume && _options is not null)
-                                _options.StartAfter = cursor.Current.Last().ResumeToken;
-
-                            if (OnChangesAsync != null)
-                            {
-                                await OnChangesAsync.InvokeAllAsync(
-                                    cursor.Current
-                                          .Where(d => d.OperationType != ChangeStreamOperationType.Invalidate)
-                                          .Select(d => d.FullDocument)
-                                ).ConfigureAwait(false);
-                            }
-
-                            OnChanges?.Invoke(
-                                    cursor.Current
-                                          .Where(d => d.OperationType != ChangeStreamOperationType.Invalidate)
-                                          .Select(d => d.FullDocument));
-
-                            if (OnChangesCSDAsync != null)
-                                await OnChangesCSDAsync.InvokeAllAsync(cursor.Current).ConfigureAwait(false);
-
-                            OnChangesCSD?.Invoke(cursor.Current);
+                            await OnChangesAsync.InvokeAllAsync(
+                                cursor.Current
+                                      .Where(d => d.OperationType != ChangeStreamOperationType.Invalidate)
+                                      .Select(d => d.FullDocument)
+                            ).ConfigureAwait(false);
                         }
+
+                        OnChanges?.Invoke(
+                                cursor.Current
+                                      .Where(d => d.OperationType != ChangeStreamOperationType.Invalidate)
+                                      .Select(d => d.FullDocument));
+
+                        if (OnChangesCSDAsync != null)
+                            await OnChangesCSDAsync.InvokeAllAsync(cursor.Current).ConfigureAwait(false);
+
+                        OnChangesCSD?.Invoke(cursor.Current);
                     }
+                }
 
-                    OnStop?.Invoke();
+                OnStop?.Invoke();
 
-                    if (_cancelToken.IsCancellationRequested)
+                if (_cancelToken.IsCancellationRequested)
+                {
+                    if (OnChangesAsync != null)
                     {
-                        if (OnChangesAsync != null)
-                        {
-                            foreach (var h in OnChangesAsync.GetHandlers())
-                                OnChangesAsync -= h;
-                        }
+                        foreach (var h in OnChangesAsync.GetHandlers())
+                            OnChangesAsync -= h;
+                    }
 
-                        if (OnChangesCSDAsync != null)
-                        {
-                            foreach (var h in OnChangesCSDAsync.GetHandlers())
-                                OnChangesCSDAsync -= h;
-                        }
+                    if (OnChangesCSDAsync != null)
+                    {
+                        foreach (var h in OnChangesCSDAsync.GetHandlers())
+                            OnChangesCSDAsync -= h;
+                    }
 
-                        if (OnChanges != null)
-                        {
-                            foreach (Action<IEnumerable<T>> a in OnChanges.GetInvocationList())
-                                OnChanges -= a;
-                        }
+                    if (OnChanges != null)
+                    {
+                        foreach (Action<IEnumerable<T>> a in OnChanges.GetInvocationList())
+                            OnChanges -= a;
+                    }
 
-                        if (OnChangesCSD != null)
-                        {
-                            foreach (Action<IEnumerable<ChangeStreamDocument<T>>> a in OnChangesCSD.GetInvocationList())
-                                OnChangesCSD -= a;
-                        }
+                    if (OnChangesCSD != null)
+                    {
+                        foreach (Action<IEnumerable<ChangeStreamDocument<T>>> a in OnChangesCSD.GetInvocationList())
+                            OnChangesCSD -= a;
+                    }
 
-                        if (OnError != null)
-                        {
-                            foreach (Action<Exception> a in OnError.GetInvocationList())
-                                OnError -= a;
-                        }
+                    if (OnError != null)
+                    {
+                        foreach (Action<Exception> a in OnError.GetInvocationList())
+                            OnError -= a;
+                    }
 
-                        if (OnStop != null)
-                        {
-                            foreach (Action a in OnStop.GetInvocationList())
-                                OnStop -= a;
-                        }
+                    if (OnStop != null)
+                    {
+                        foreach (Action a in OnStop.GetInvocationList())
+                            OnStop -= a;
                     }
                 }
-                catch (Exception x)
-                {
-                    OnError?.Invoke(x);
-                }
+            }
+            catch (Exception x)
+            {
+                OnError?.Invoke(x);
             }
         }
     }
+}
 
-    [Flags]
-    public enum EventType
-    {
-        Created = 1 << 1,
-        Updated = 1 << 2,
-        Deleted = 1 << 3
-    }
+[Flags]
+public enum EventType
+{
+    Created = 1 << 1,
+    Updated = 1 << 2,
+    Deleted = 1 << 3
 }
diff --git a/MongoDB.Entities/DB/DB.Collection.cs b/MongoDB.Entities/DB/DB.Collection.cs
index 6272f4958..b0b98539d 100644
--- a/MongoDB.Entities/DB/DB.Collection.cs
+++ b/MongoDB.Entities/DB/DB.Collection.cs
@@ -8,9 +8,9 @@ namespace MongoDB.Entities
 {
     public static partial class DB
     {
-        internal static IMongoCollection<JoinRecord> GetRefCollection<T>(string name) where T : IEntity
+        internal static IMongoCollection<JoinRecord<string, string>> GetRefCollection<T>(string name) where T : IEntity
         {
-            return Context.GetCollection<JoinRecord>(name);
+            return Context.GetCollection<JoinRecord<string, string>>(name);
         }
 
         /// <summary>
diff --git a/MongoDB.Entities/DBContext/DBContext.Collection.cs b/MongoDB.Entities/DBContext/DBContext.Collection.cs
index ee05df23f..ffa8f4f68 100644
--- a/MongoDB.Entities/DBContext/DBContext.Collection.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Collection.cs
@@ -15,7 +15,7 @@ public partial class DBContext
     /// <param name="options">The options to use for collection creation</param>
     /// <param name="cancellation">An optional cancellation token</param>
     /// <param name="collectionName"></param>
-    public Task CreateCollectionAsync<T>(Action<CreateCollectionOptions<T>> options, CancellationToken cancellation = default, string? collectionName = null) where T : IEntity
+    public Task CreateCollectionAsync<T>(Action<CreateCollectionOptions<T>> options, CancellationToken cancellation = default, string? collectionName = null)
     {
         var opts = new CreateCollectionOptions<T>();
         options(opts);
@@ -29,7 +29,7 @@ public Task CreateCollectionAsync<T>(Action<CreateCollectionOptions<T>> options,
     /// <para>TIP: When deleting a collection, all relationships associated with that entity type is also deleted.</para>
     /// </summary>
     /// <typeparam name="T">The entity type to drop the collection of</typeparam>
-    public async Task DropCollectionAsync<T>(string? collectionName = null) where T : IEntity
+    public async Task DropCollectionAsync<T>(string? collectionName = null)
     {
         var tasks = new List<Task>();
         var db = Database;
diff --git a/MongoDB.Entities/DBContext/DBContext.Count.cs b/MongoDB.Entities/DBContext/DBContext.Count.cs
index 76dc3d07f..7d628765f 100644
--- a/MongoDB.Entities/DBContext/DBContext.Count.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Count.cs
@@ -16,7 +16,7 @@ public partial class DBContext
     /// <param name="collectionName">To override the default collection name</param>
     /// <param name="collection">To override the default collection</param>
     /// <param name="cancellation">An optional cancellation token</param>
-    public Task<long> CountEstimatedAsync<T>(CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
+    public Task<long> CountEstimatedAsync<T>(CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null)
     {
         return Collection(collectionName, collection).EstimatedDocumentCountAsync(cancellationToken: cancellation);
     }
@@ -31,7 +31,7 @@ public Task<long> CountEstimatedAsync<T>(CancellationToken cancellation = defaul
     /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
     /// <param name="collectionName"></param>
     /// <param name="collection"></param>
-    public Task<long> CountAsync<T>(Expression<Func<T, bool>> expression, CancellationToken cancellation = default, CountOptions? options = null, bool ignoreGlobalFilters = false, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
+    public Task<long> CountAsync<T>(Expression<Func<T, bool>> expression, CancellationToken cancellation = default, CountOptions? options = null, bool ignoreGlobalFilters = false, string? collectionName = null, IMongoCollection<T>? collection = null)
     {
         return CountAsync((FilterDefinition<T>)expression, cancellation, options, ignoreGlobalFilters, collection: collection, collectionName: collectionName);
     }
@@ -43,9 +43,9 @@ public Task<long> CountAsync<T>(Expression<Func<T, bool>> expression, Cancellati
     /// <param name="cancellation">An optional cancellation token</param>
     /// <param name="collectionName"></param>
     /// <param name="collection"></param>
-    public Task<long> CountAsync<T>(CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
+    public Task<long> CountAsync<T>(CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null)
     {
-        return CountAsync<T>(_ => true, cancellation, collectionName: collectionName, collection: collection);
+        return CountAsync(_ => true, cancellation, collectionName: collectionName, collection: collection);
 
     }
 
@@ -59,7 +59,7 @@ public Task<long> CountAsync<T>(CancellationToken cancellation = default, string
     /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
     /// <param name="collectionName"></param>
     /// <param name="collection"></param>
-    public Task<long> CountAsync<T>(FilterDefinition<T> filter, CancellationToken cancellation = default, CountOptions? options = null, bool ignoreGlobalFilters = false, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
+    public Task<long> CountAsync<T>(FilterDefinition<T> filter, CancellationToken cancellation = default, CountOptions? options = null, bool ignoreGlobalFilters = false, string? collectionName = null, IMongoCollection<T>? collection = null)
     {
         filter = Logic.MergeWithGlobalFilter(ignoreGlobalFilters, _globalFilters, filter);
         return
@@ -78,7 +78,7 @@ public Task<long> CountAsync<T>(FilterDefinition<T> filter, CancellationToken ca
     /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
     /// <param name="collectionName"></param>
     /// <param name="collection"></param>
-    public Task<long> CountAsync<T>(Func<FilterDefinitionBuilder<T>, FilterDefinition<T>> filter, CancellationToken cancellation = default, CountOptions? options = null, bool ignoreGlobalFilters = false, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
+    public Task<long> CountAsync<T>(Func<FilterDefinitionBuilder<T>, FilterDefinition<T>> filter, CancellationToken cancellation = default, CountOptions? options = null, bool ignoreGlobalFilters = false, string? collectionName = null, IMongoCollection<T>? collection = null)
     {
         return CountAsync(filter(Builders<T>.Filter), cancellation, options, ignoreGlobalFilters, collectionName: collectionName, collection: collection);
     }
diff --git a/MongoDB.Entities/DBContext/DBContext.Delete.cs b/MongoDB.Entities/DBContext/DBContext.Delete.cs
index b1ea05eb5..614e3b196 100644
--- a/MongoDB.Entities/DBContext/DBContext.Delete.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Delete.cs
@@ -17,7 +17,9 @@ private void ThrowIfCancellationNotSupported(CancellationToken cancellation = de
             throw new NotSupportedException("Cancellation is only supported within transactions for delete operations!");
     }
 
-    private async Task<DeleteResult> DeleteCascadingAsync<T>(IEnumerable<string> IDs, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
+    private async Task<DeleteResult> DeleteCascadingAsync<T, TId>(IEnumerable<TId?> IDs, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null)
+        where TId : IComparable<TId>, IEquatable<TId>
+        where T : IEntity<TId>
     {
         // note: cancellation should not be enabled outside of transactions because multiple collections are involved 
         //       and premature cancellation could cause data inconsistencies.
@@ -34,13 +36,14 @@ private async Task<DeleteResult> DeleteCascadingAsync<T>(IEnumerable<string> IDs
         // note: db.listCollections() mongo command does not support transactions.
         //       so don't add session support here.
         var collNamesCursor = await ListCollectionNamesAsync(options, cancellation).ConfigureAwait(false);
-
+        IDs = IDs.OfType<TId>();
+        var casted = IDs.Cast<object>();
         foreach (var cName in await collNamesCursor.ToListAsync(cancellation).ConfigureAwait(false))
         {
             tasks.Add(
                 Session is null
-                ? Collection<JoinRecord>(cName).DeleteManyAsync(r => IDs.Contains(r.ChildID) || IDs.Contains(r.ParentID))
-                : Collection<JoinRecord>(cName).DeleteManyAsync(Session, r => IDs.Contains(r.ChildID) || IDs.Contains(r.ParentID), null, cancellation));
+                ? Collection<JoinRecord<object, object>>(cName).DeleteManyAsync(r => casted.Contains(r.ID.ChildID) || casted.Contains(r.ID.ParentID))
+                : Collection<JoinRecord<object, object>>(cName).DeleteManyAsync(Session, r => casted.Contains(r.ID.ChildID) || casted.Contains(r.ID.ParentID), null, cancellation));
         }
 
         var delResTask =
@@ -54,8 +57,8 @@ Session is null
         {
             tasks.Add(
                 Session is null
-                ? Collection<FileChunk>().DeleteManyAsync(x => IDs.Contains(x.FileID))
-                : Collection<FileChunk>().DeleteManyAsync(Session, x => IDs.Contains(x.FileID), null, cancellation));
+                ? Collection<FileChunk<TId>>().DeleteManyAsync(x => IDs.Contains(x.FileID))
+                : Collection<FileChunk<TId>>().DeleteManyAsync(Session, x => IDs.Contains(x.FileID), null, cancellation));
         }
 
         await Task.WhenAll(tasks).ConfigureAwait(false);
@@ -69,14 +72,17 @@ Session is null
     /// <para>HINT: If this entity is referenced by one-to-many/many-to-many relationships, those references are also deleted.</para>
     /// </summary>
     /// <typeparam name="T">The type of entity</typeparam>
+    /// <typeparam name="TId">ID type</typeparam>
     /// <param name="ID">The Id of the entity to delete</param>
     /// <param name="cancellation">An optional cancellation token</param>
     /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
     /// <param name="collectionName"></param>
     /// <param name="collection"></param>
-    public Task<DeleteResult> DeleteAsync<T>(string ID, CancellationToken cancellation = default, bool ignoreGlobalFilters = false, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
+    public Task<DeleteResult> DeleteAsync<T, TId>(TId ID, CancellationToken cancellation = default, bool ignoreGlobalFilters = false, string? collectionName = null, IMongoCollection<T>? collection = null)
+        where TId : IComparable<TId>, IEquatable<TId>
+        where T : IEntity<TId>
     {
-        return DeleteAsync(Builders<T>.Filter.Eq(e => e.ID, ID), cancellation, ignoreGlobalFilters: ignoreGlobalFilters, collection: collection, collectionName: collectionName);
+        return DeleteAsync<T, TId>(Builders<T>.Filter.Eq(e => e.ID, ID), cancellation, ignoreGlobalFilters: ignoreGlobalFilters, collection: collection, collectionName: collectionName);
     }
 
     /// <summary>
@@ -85,14 +91,17 @@ public Task<DeleteResult> DeleteAsync<T>(string ID, CancellationToken cancellati
     /// <para>TIP: Try to keep the number of entities to delete under 100 in a single call</para>
     /// </summary>
     /// <typeparam name="T">The type of entity</typeparam>
+    /// <typeparam name="TId">ID type</typeparam>
     /// <param name="IDs">An IEnumerable of entity IDs</param>
     /// <param name="cancellation">An optional cancellation token</param>
     /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
     /// <param name="collectionName"></param>
     /// <param name="collection"></param>
-    public Task<DeleteResult> DeleteAsync<T>(IEnumerable<string> IDs, CancellationToken cancellation = default, bool ignoreGlobalFilters = false, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
+    public Task<DeleteResult> DeleteAsync<T, TId>(IEnumerable<TId> IDs, CancellationToken cancellation = default, bool ignoreGlobalFilters = false, string? collectionName = null, IMongoCollection<T>? collection = null)
+        where TId : IComparable<TId>, IEquatable<TId>
+        where T : IEntity<TId>
     {
-        return DeleteAsync(Builders<T>.Filter.In(e => e.ID, IDs), cancellation, ignoreGlobalFilters: ignoreGlobalFilters, collection: collection, collectionName: collectionName);
+        return DeleteAsync<T, TId>(Builders<T>.Filter.In(e => e.ID, IDs), cancellation, ignoreGlobalFilters: ignoreGlobalFilters, collection: collection, collectionName: collectionName);
     }
 
     /// <summary>
@@ -101,15 +110,18 @@ public Task<DeleteResult> DeleteAsync<T>(IEnumerable<string> IDs, CancellationTo
     /// <para>TIP: Try to keep the number of entities to delete under 100 in a single call</para>
     /// </summary>
     /// <typeparam name="T">The type of entity</typeparam>
+    /// <typeparam name="TId">ID type</typeparam>
     /// <param name="expression">A lambda expression for matching entities to delete.</param>
     /// <param name="cancellation">An optional cancellation token</param>
     /// <param name="collation">An optional collation object</param>
     /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
     /// <param name="collectionName"></param>
     /// <param name="collection"></param>
-    public Task<DeleteResult> DeleteAsync<T>(Expression<Func<T, bool>> expression, CancellationToken cancellation = default, Collation? collation = null, bool ignoreGlobalFilters = false, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
+    public Task<DeleteResult> DeleteAsync<T, TId>(Expression<Func<T, bool>> expression, CancellationToken cancellation = default, Collation? collation = null, bool ignoreGlobalFilters = false, string? collectionName = null, IMongoCollection<T>? collection = null)
+        where TId : IComparable<TId>, IEquatable<TId>
+        where T : IEntity<TId>
     {
-        return DeleteAsync(Builders<T>.Filter.Where(expression), cancellation, collation, ignoreGlobalFilters, collection: collection, collectionName: collectionName);
+        return DeleteAsync<T, TId>(Builders<T>.Filter.Where(expression), cancellation, collation, ignoreGlobalFilters, collection: collection, collectionName: collectionName);
     }
 
     /// <summary>
@@ -118,15 +130,18 @@ public Task<DeleteResult> DeleteAsync<T>(Expression<Func<T, bool>> expression, C
     /// <para>HINT: If these entities are referenced by one-to-many/many-to-many relationships, those references are also deleted.</para>
     /// </summary>
     /// <typeparam name="T">Any class that implements IEntity</typeparam>
+    /// <typeparam name="TId">ID type</typeparam>
     /// <param name="filter">f => f.Eq(x => x.Prop, Value) &amp; f.Gt(x => x.Prop, Value)</param>
     /// <param name="cancellation">An optional cancellation token</param>
     /// <param name="collation">An optional collation object</param>
     /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
     /// <param name="collectionName"></param>
     /// <param name="collection"></param>
-    public Task<DeleteResult> DeleteAsync<T>(Func<FilterDefinitionBuilder<T>, FilterDefinition<T>> filter, CancellationToken cancellation = default, Collation? collation = null, bool ignoreGlobalFilters = false, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
+    public Task<DeleteResult> DeleteAsync<T, TId>(Func<FilterDefinitionBuilder<T>, FilterDefinition<T>> filter, CancellationToken cancellation = default, Collation? collation = null, bool ignoreGlobalFilters = false, string? collectionName = null, IMongoCollection<T>? collection = null)
+        where TId : IComparable<TId>, IEquatable<TId>
+        where T : IEntity<TId>
     {
-        return DeleteAsync(filter(Builders<T>.Filter), cancellation, collation, ignoreGlobalFilters, collection: collection, collectionName: collectionName);
+        return DeleteAsync<T, TId>(filter(Builders<T>.Filter), cancellation, collation, ignoreGlobalFilters, collection: collection, collectionName: collectionName);
     }
 
     /// <summary>
@@ -135,18 +150,21 @@ public Task<DeleteResult> DeleteAsync<T>(Func<FilterDefinitionBuilder<T>, Filter
     /// <para>HINT: If these entities are referenced by one-to-many/many-to-many relationships, those references are also deleted.</para>
     /// </summary>
     /// <typeparam name="T">Any class that implements IEntity</typeparam>
+    /// <typeparam name="TId">ID type</typeparam>
     /// <param name="filter">A filter definition for matching entities to delete.</param>
     /// <param name="cancellation">An optional cancellation token</param>
     /// <param name="collation">An optional collation object</param>
     /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
     /// <param name="collectionName"></param>
     /// <param name="collection"></param>
-    public async Task<DeleteResult> DeleteAsync<T>(FilterDefinition<T> filter, CancellationToken cancellation = default, Collation? collation = null, bool ignoreGlobalFilters = false, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
+    public async Task<DeleteResult> DeleteAsync<T, TId>(FilterDefinition<T> filter, CancellationToken cancellation = default, Collation? collation = null, bool ignoreGlobalFilters = false, string? collectionName = null, IMongoCollection<T>? collection = null)
+        where TId : IComparable<TId>, IEquatable<TId>
+        where T : IEntity<TId>
     {
         ThrowIfCancellationNotSupported(cancellation);
 
         var filterDef = Logic.MergeWithGlobalFilter(ignoreGlobalFilters, _globalFilters, filter);
-        var cursor = await new Find<T, string>(this, Collection(collectionName, collection))
+        var cursor = await new Find<T, TId, TId?>(this, Collection(collectionName, collection))
                            .Match(filter)
                            .Project(e => e.ID)
                            .Option(o => o.BatchSize = _deleteBatchSize)
@@ -163,7 +181,7 @@ public async Task<DeleteResult> DeleteAsync<T>(FilterDefinition<T> filter, Cance
             {
                 if (cursor.Current.Any())
                 {
-                    res = await DeleteCascadingAsync<T>(cursor.Current, cancellation).ConfigureAwait(false);
+                    res = await DeleteCascadingAsync<T, TId>(cursor.Current, cancellation).ConfigureAwait(false);
                     deletedCount += res.DeletedCount;
                 }
             }
diff --git a/MongoDB.Entities/DBContext/DBContext.Distinct.cs b/MongoDB.Entities/DBContext/DBContext.Distinct.cs
index 52b65b5b5..d68d71cd8 100644
--- a/MongoDB.Entities/DBContext/DBContext.Distinct.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Distinct.cs
@@ -8,9 +8,12 @@ public partial class DBContext
     /// Represents a MongoDB Distinct command where you can get back distinct values for a given property of a given Entity
     /// </summary>
     /// <typeparam name="T">Any Entity that implements IEntity interface</typeparam>
+    /// <typeparam name="TId">Id type</typeparam>
     /// <typeparam name="TProperty">The type of the property of the entity you'd like to get unique values for</typeparam>
-    public Distinct<T, TProperty> Distinct<T, TProperty>(string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
+    public Distinct<T, TId, TProperty> Distinct<T, TId, TProperty>(string? collectionName = null, IMongoCollection<T>? collection = null)
+        where TId : IComparable<TId>, IEquatable<TId>
+        where T : IEntity<TId>
     {
-        return new Distinct<T, TProperty>(this, Collection(collectionName, collection));
+        return new Distinct<T, TId, TProperty>(this, Collection(collectionName, collection));
     }
 }
diff --git a/MongoDB.Entities/DBContext/DBContext.File.cs b/MongoDB.Entities/DBContext/DBContext.File.cs
index 0c0c38598..662b877df 100644
--- a/MongoDB.Entities/DBContext/DBContext.File.cs
+++ b/MongoDB.Entities/DBContext/DBContext.File.cs
@@ -10,14 +10,14 @@ public partial class DBContext
     /// Returns a DataStreamer object to enable uploading/downloading file data directly by supplying the ID of the file entity
     /// </summary>
     /// <typeparam name="T">The file entity type</typeparam>
+    /// <typeparam name="TId">ID type</typeparam>
     /// <param name="ID">The ID of the file entity</param>
     /// <param name="collectionName"></param>
     /// <param name="collection"></param>
-    public DataStreamer<T> File<T>(string ID, string? collectionName = null, IMongoCollection<T>? collection = null) where T : FileEntity, new()
+    public DataStreamer<T, TId> File<T, TId>(TId ID, string? collectionName = null, IMongoCollection<T>? collection = null)
+        where TId : IComparable<TId>, IEquatable<TId>
+        where T : FileEntity<TId>, new()
     {
-        if (!ObjectId.TryParse(ID, out _))
-            throw new ArgumentException("The ID passed in is not of the correct format!");
-
-        return new DataStreamer<T>(new T() { ID = ID, UploadSuccessful = true }, this, Collection<T>(collectionName, collection));
+        return new DataStreamer<T, TId>(new T() { ID = ID, UploadSuccessful = true }, this, Collection(collectionName, collection));
     }
 }
diff --git a/MongoDB.Entities/DBContext/DBContext.Find.cs b/MongoDB.Entities/DBContext/DBContext.Find.cs
index 85d10b264..e8cedbc27 100644
--- a/MongoDB.Entities/DBContext/DBContext.Find.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Find.cs
@@ -8,18 +8,24 @@ public partial class DBContext
     /// Starts a find command for the given entity type
     /// </summary>
     /// <typeparam name="T">The type of entity</typeparam>
-    public Find<T> Find<T>(string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
+    /// <typeparam name="TId">ID type</typeparam>
+    public Find<T, TId> Find<T, TId>(string? collectionName = null, IMongoCollection<T>? collection = null)
+        where TId : IComparable<TId>, IEquatable<TId>
+        where T : IEntity<TId>
     {
-        return new Find<T>(this, Collection(collectionName, collection));
+        return new Find<T, TId>(this, Collection(collectionName, collection));
     }
 
     /// <summary>
     /// Starts a find command with projection support for the given entity type
     /// </summary>
     /// <typeparam name="T">The type of entity</typeparam>
+    /// <typeparam name="TId">ID type</typeparam>
     /// <typeparam name="TProjection">The type of the end result</typeparam>
-    public Find<T, TProjection> Find<T, TProjection>(string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
+    public Find<T, TId, TProjection> Find<T, TId, TProjection>(string? collectionName = null, IMongoCollection<T>? collection = null)
+        where TId : IComparable<TId>, IEquatable<TId>
+        where T : IEntity<TId>
     {
-        return new Find<T, TProjection>(this, Collection(collectionName, collection));
+        return new Find<T, TId, TProjection>(this, Collection(collectionName, collection));
     }
 }
diff --git a/MongoDB.Entities/DBContext/DBContext.Fluent.cs b/MongoDB.Entities/DBContext/DBContext.Fluent.cs
index d6f3f05cf..5717efca1 100644
--- a/MongoDB.Entities/DBContext/DBContext.Fluent.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Fluent.cs
@@ -12,7 +12,7 @@ public partial class DBContext
         /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
         /// <param name="collectionName"></param>
         /// <param name="collection"></param>
-        public IAggregateFluent<T> Fluent<T>(AggregateOptions? options = null, bool ignoreGlobalFilters = false, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
+        public IAggregateFluent<T> Fluent<T>(AggregateOptions? options = null, bool ignoreGlobalFilters = false, string? collectionName = null, IMongoCollection<T>? collection = null)
         {
             var globalFilter = Logic.MergeWithGlobalFilter(ignoreGlobalFilters, _globalFilters, Builders<T>.Filter.Empty);
 
@@ -40,7 +40,7 @@ public IAggregateFluent<T> Fluent<T>(AggregateOptions? options = null, bool igno
         /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
         /// <param name="collectionName"></param>
         /// <param name="collection"></param>
-        public IAggregateFluent<T> FluentTextSearch<T>(Search searchType, string searchTerm, bool caseSensitive = false, bool diacriticSensitive = false, string? language = null, AggregateOptions? options = null, bool ignoreGlobalFilters = false, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
+        public IAggregateFluent<T> FluentTextSearch<T>(Search searchType, string searchTerm, bool caseSensitive = false, bool diacriticSensitive = false, string? language = null, AggregateOptions? options = null, bool ignoreGlobalFilters = false, string? collectionName = null, IMongoCollection<T>? collection = null) 
         {
             var globalFilter = Logic.MergeWithGlobalFilter(ignoreGlobalFilters, _globalFilters, Builders<T>.Filter.Empty);
 
diff --git a/MongoDB.Entities/DBContext/DBContext.GeoNear.cs b/MongoDB.Entities/DBContext/DBContext.GeoNear.cs
index bc1274aa9..2226e9d7b 100644
--- a/MongoDB.Entities/DBContext/DBContext.GeoNear.cs
+++ b/MongoDB.Entities/DBContext/DBContext.GeoNear.cs
@@ -25,7 +25,7 @@ public partial class DBContext
         /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
         /// <param name="collectionName"></param>
         /// <param name="collection"></param>
-        public IAggregateFluent<T> GeoNear<T>(Coordinates2D NearCoordinates, Expression<Func<T, object>>? DistanceField, bool Spherical = true, double? MaxDistance = null, double? MinDistance = null, int? Limit = null, BsonDocument? Query = null, double? DistanceMultiplier = null, Expression<Func<T, object>>? IncludeLocations = null, string? IndexKey = null, AggregateOptions? options = null, bool ignoreGlobalFilters = false, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
+        public IAggregateFluent<T> GeoNear<T>(Coordinates2D NearCoordinates, Expression<Func<T, object>>? DistanceField, bool Spherical = true, double? MaxDistance = null, double? MinDistance = null, int? Limit = null, BsonDocument? Query = null, double? DistanceMultiplier = null, Expression<Func<T, object>>? IncludeLocations = null, string? IndexKey = null, AggregateOptions? options = null, bool ignoreGlobalFilters = false, string? collectionName = null, IMongoCollection<T>? collection = null)
         {
             var globalFilter = Logic.MergeWithGlobalFilter(ignoreGlobalFilters, _globalFilters, Builders<T>.Filter.Empty);
 
diff --git a/MongoDB.Entities/DBContext/DBContext.Index.cs b/MongoDB.Entities/DBContext/DBContext.Index.cs
index 8f500cd67..dcc8488ae 100644
--- a/MongoDB.Entities/DBContext/DBContext.Index.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Index.cs
@@ -9,9 +9,12 @@ public partial class DBContext
         /// <para>TIP: Define the keys first with .Key() method and finally call the .Create() method.</para>
         /// </summary>
         /// <typeparam name="T">Any class that implements IEntity</typeparam>
-        public Index<T> Index<T>(string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
+        /// <typeparam name="TId">ID type</typeparam>
+        public Index<T, TId> Index<T, TId>(string? collectionName = null, IMongoCollection<T>? collection = null)
+            where TId : IComparable<TId>, IEquatable<TId>
+            where T : IEntity<TId>
         {
-            return new Index<T>(this, Collection(collectionName, collection));
+            return new Index<T, TId>(this, Collection(collectionName, collection));
         }
     }
 }
diff --git a/MongoDB.Entities/DBContext/DBContext.Insert.cs b/MongoDB.Entities/DBContext/DBContext.Insert.cs
index 4e66f8163..3617b3eb2 100644
--- a/MongoDB.Entities/DBContext/DBContext.Insert.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Insert.cs
@@ -12,23 +12,29 @@ public partial class DBContext
     {
         private static readonly BulkWriteOptions _unOrdBlkOpts = new() { IsOrdered = false };
         private static readonly UpdateOptions _updateOptions = new() { IsUpsert = true };
-        private Task<UpdateResult> SavePartial<T>(T entity, Expression<Func<T, object>> members, CancellationToken cancellation, bool excludeMode = false, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
+        private Task<UpdateResult> SavePartial<T, TId>(T entity, Expression<Func<T, object>> members, CancellationToken cancellation, bool excludeMode = false, string? collectionName = null, IMongoCollection<T>? collection = null)
+            where TId : IComparable<TId>, IEquatable<TId>
+            where T : IEntity<TId>
         {
-            PrepAndCheckIfInsert(entity); //just prep. we don't care about inserts here
+            PrepAndCheckIfInsert<T, TId>(entity); //just prep. we don't care about inserts here
+            var filter = Builders<T>.Filter.Eq(e => e.ID, entity.ID);
+            var update = Builders<T>.Update.Combine(Logic.BuildUpdateDefs<T, TId>(entity, members, this, excludeMode));
             return
                 Session == null
-                ? Collection(collectionName, collection).UpdateOneAsync(e => e.ID == entity.ID, Builders<T>.Update.Combine(Logic.BuildUpdateDefs(entity, members, excludeMode)), _updateOptions, cancellation)
-                : Collection(collectionName, collection).UpdateOneAsync(Session, e => e.ID == entity.ID, Builders<T>.Update.Combine(Logic.BuildUpdateDefs(entity, members, excludeMode)), _updateOptions, cancellation);
+                ? Collection(collectionName, collection).UpdateOneAsync(filter, update, _updateOptions, cancellation)
+                : Collection(collectionName, collection).UpdateOneAsync(Session, filter, update, _updateOptions, cancellation);
         }
 
-        private Task<BulkWriteResult<T>> SavePartial<T>(IEnumerable<T> entities, Expression<Func<T, object>> members, CancellationToken cancellation, bool excludeMode = false, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
+        private Task<BulkWriteResult<T>> SavePartial<T, TId>(IEnumerable<T> entities, Expression<Func<T, object>> members, CancellationToken cancellation, bool excludeMode = false, string? collectionName = null, IMongoCollection<T>? collection = null)
+                      where TId : IComparable<TId>, IEquatable<TId>
+            where T : IEntity<TId>
         {
             var models = entities.Select(ent =>
             {
-                PrepAndCheckIfInsert(ent); //just prep. we don't care about inserts here
+                PrepAndCheckIfInsert<T, TId>(ent); //just prep. we don't care about inserts here
                 return new UpdateOneModel<T>(
                             filter: Builders<T>.Filter.Eq(e => e.ID, ent.ID),
-                            update: Builders<T>.Update.Combine(Logic.BuildUpdateDefs(ent, members, excludeMode)))
+                            update: Builders<T>.Update.Combine(Logic.BuildUpdateDefs<T, TId>(ent, members, this, excludeMode)))
                 { IsUpsert = true };
             }).ToList();
             return Session == null
@@ -36,10 +42,12 @@ private Task<BulkWriteResult<T>> SavePartial<T>(IEnumerable<T> entities, Express
                 : Collection(collectionName, collection).BulkWriteAsync(Session, models, _unOrdBlkOpts, cancellation);
         }
 
-        private bool PrepAndCheckIfInsert<T>(T entity) where T : IEntity
+        private bool PrepAndCheckIfInsert<T, TId>(T entity)
+            where TId : IComparable<TId>, IEquatable<TId>
+            where T : IEntity<TId>
         {
             var cache = Cache<T>();
-            if (string.IsNullOrEmpty(entity.ID))
+            if (EqualityComparer<TId?>.Default.Equals(entity.ID, default))
             {
                 entity.ID = entity.GenerateNewID();
                 if (cache.HasCreatedOn) ((ICreatedOn)entity).CreatedOn = DateTime.UtcNow;
@@ -56,15 +64,18 @@ private bool PrepAndCheckIfInsert<T>(T entity) where T : IEntity
         /// If ID value is null, a new entity is created. If ID has a value, then existing entity is replaced.
         /// </summary>
         /// <typeparam name="T">The type of entity</typeparam>
+        /// <typeparam name="TId">ID type</typeparam>
         /// <param name="entity">The instance to persist</param>
         /// <param name="cancellation">And optional cancellation token</param>
         /// <param name="collectionName"></param>
         /// <param name="collection"></param>
-        public Task InsertAsync<T>(T entity, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
+        public Task InsertAsync<T, TId>(T entity, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null)
+                     where TId : IComparable<TId>, IEquatable<TId>
+            where T : IEntity<TId>
         {
             SetModifiedBySingle(entity);
             OnBeforeSave(entity);
-            PrepAndCheckIfInsert(entity);
+            PrepAndCheckIfInsert<T, TId>(entity);
             return Session == null
                    ? Collection(collectionName, collection).InsertOneAsync(entity, null, cancellation)
                    : Collection(collectionName, collection).InsertOneAsync(Session, entity, null, cancellation);
@@ -75,18 +86,21 @@ public Task InsertAsync<T>(T entity, CancellationToken cancellation = default, s
         /// If ID value is null, a new entity is created. If ID has a value, then existing entity is replaced.
         /// </summary>
         /// <typeparam name="T">The type of entity</typeparam>
+        /// <typeparam name="TId">ID type</typeparam>
         /// <param name="entities">The entities to persist</param>
         /// <param name="cancellation">And optional cancellation token</param>
         /// <param name="collectionName"></param>
         /// <param name="collection"></param>
-        public Task<BulkWriteResult<T>> InsertAsync<T>(IEnumerable<T> entities, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
+        public Task<BulkWriteResult<T>> InsertAsync<T, TId>(IEnumerable<T> entities, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null)
+                     where TId : IComparable<TId>, IEquatable<TId>
+            where T : IEntity<TId>
         {
             SetModifiedByMultiple(entities);
             foreach (var ent in entities) OnBeforeSave(ent);
 
             var models = entities.Select(ent =>
             {
-                PrepAndCheckIfInsert(ent);
+                PrepAndCheckIfInsert<T, TId>(ent);
                 return new InsertOneModel<T>(ent);
             }).ToList();
 
diff --git a/MongoDB.Entities/DBContext/DBContext.PagedSearch.cs b/MongoDB.Entities/DBContext/DBContext.PagedSearch.cs
index 891df99cd..56e9d1412 100644
--- a/MongoDB.Entities/DBContext/DBContext.PagedSearch.cs
+++ b/MongoDB.Entities/DBContext/DBContext.PagedSearch.cs
@@ -1,26 +1,31 @@
 using MongoDB.Driver;
 
-namespace MongoDB.Entities
+namespace MongoDB.Entities;
+
+public partial class DBContext
 {
-    public partial class DBContext
+    /// <summary>
+    /// Represents an aggregation query that retrieves results with easy paging support.
+    /// </summary>
+    /// <typeparam name="T">Any class that implements IEntity</typeparam>
+    /// <typeparam name="TId">ID type</typeparam>
+    public PagedSearch<T, TId> PagedSearch<T, TId>(string? collectionName = null, IMongoCollection<T>? collection = null)
+        where TId : IComparable<TId>, IEquatable<TId>
+        where T : IEntity<TId>
     {
-        /// <summary>
-        /// Represents an aggregation query that retrieves results with easy paging support.
-        /// </summary>
-        /// <typeparam name="T">Any class that implements IEntity</typeparam>
-        public PagedSearch<T> PagedSearch<T>(string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
-        {
-            return new PagedSearch<T>(this, Collection(collectionName, collection));
-        }
+        return new PagedSearch<T, TId>(this, Collection(collectionName, collection));
+    }
 
-        /// <summary>
-        /// Represents an aggregation query that retrieves results with easy paging support.
-        /// </summary>
-        /// <typeparam name="T">Any class that implements IEntity</typeparam>
-        /// <typeparam name="TProjection">The type you'd like to project the results to.</typeparam>
-        public PagedSearch<T, TProjection> PagedSearch<T, TProjection>(string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
-        {
-            return new PagedSearch<T, TProjection>(this, Collection(collectionName, collection));
-        }
+    /// <summary>
+    /// Represents an aggregation query that retrieves results with easy paging support.
+    /// </summary>
+    /// <typeparam name="T">Any class that implements IEntity</typeparam>
+    /// <typeparam name="TId">ID type</typeparam>
+    /// <typeparam name="TProjection">The type you'd like to project the results to.</typeparam>
+    public PagedSearch<T, TId, TProjection> PagedSearch<T, TId, TProjection>(string? collectionName = null, IMongoCollection<T>? collection = null)
+        where TId : IComparable<TId>, IEquatable<TId>
+        where T : IEntity<TId>
+    {
+        return new PagedSearch<T, TId, TProjection>(this, Collection(collectionName, collection));
     }
 }
diff --git a/MongoDB.Entities/DBContext/DBContext.Pipeline.cs b/MongoDB.Entities/DBContext/DBContext.Pipeline.cs
index cd35efeed..48f74517c 100644
--- a/MongoDB.Entities/DBContext/DBContext.Pipeline.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Pipeline.cs
@@ -22,7 +22,7 @@ public partial class DBContext
         /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
         /// <param name="collectionName"></param>
         /// <param name="collection"></param>
-        public Task<IAsyncCursor<TResult>> PipelineCursorAsync<T, TResult>(Template<T, TResult> template, AggregateOptions? options = null, CancellationToken cancellation = default, bool ignoreGlobalFilters = false, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
+        public Task<IAsyncCursor<TResult>> PipelineCursorAsync<T, TResult>(Template<T, TResult> template, AggregateOptions? options = null, CancellationToken cancellation = default, bool ignoreGlobalFilters = false, string? collectionName = null, IMongoCollection<T>? collection = null)
         {
             template = MergeTemplateGlobalFilter(template, ignoreGlobalFilters);
             return Session == null
@@ -42,7 +42,7 @@ public Task<IAsyncCursor<TResult>> PipelineCursorAsync<T, TResult>(Template<T, T
         /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
         /// <param name="collectionName"></param>
         /// <param name="collection"></param>
-        public async Task<List<TResult>> PipelineAsync<T, TResult>(Template<T, TResult> template, AggregateOptions? options = null, CancellationToken cancellation = default, bool ignoreGlobalFilters = false, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
+        public async Task<List<TResult>> PipelineAsync<T, TResult>(Template<T, TResult> template, AggregateOptions? options = null, CancellationToken cancellation = default, bool ignoreGlobalFilters = false, string? collectionName = null, IMongoCollection<T>? collection = null)
         {
             var list = new List<TResult>();
             using (var cursor = await PipelineCursorAsync(template, options, cancellation, ignoreGlobalFilters: ignoreGlobalFilters, collectionName: collectionName, collection: collection).ConfigureAwait(false))
@@ -67,7 +67,7 @@ public async Task<List<TResult>> PipelineAsync<T, TResult>(Template<T, TResult>
         /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
         /// <param name="collectionName"></param>
         /// <param name="collection"></param>
-        public async Task<TResult> PipelineSingleAsync<T, TResult>(Template<T, TResult> template, AggregateOptions? options = null, CancellationToken cancellation = default, bool ignoreGlobalFilters = false, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
+        public async Task<TResult> PipelineSingleAsync<T, TResult>(Template<T, TResult> template, AggregateOptions? options = null, CancellationToken cancellation = default, bool ignoreGlobalFilters = false, string? collectionName = null, IMongoCollection<T>? collection = null)
         {
 
             AggregateOptions opts = options ?? new AggregateOptions();
@@ -88,7 +88,9 @@ public async Task<TResult> PipelineSingleAsync<T, TResult>(Template<T, TResult>
         /// <param name="options">The options for the aggregation. This is not required.</param>
         /// <param name="cancellation">An optional cancellation token</param>
         /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
-        public async Task<TResult> PipelineFirstAsync<T, TResult>(Template<T, TResult> template, AggregateOptions? options = null, CancellationToken cancellation = default, bool ignoreGlobalFilters = false, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
+        /// <param name="collectionName"></param>
+        /// <param name="collection"></param>
+        public async Task<TResult> PipelineFirstAsync<T, TResult>(Template<T, TResult> template, AggregateOptions? options = null, CancellationToken cancellation = default, bool ignoreGlobalFilters = false, string? collectionName = null, IMongoCollection<T>? collection = null)
         {
 
             var opts = options ?? new AggregateOptions();
@@ -99,7 +101,7 @@ public async Task<TResult> PipelineFirstAsync<T, TResult>(Template<T, TResult> t
             return cursor.Current.SingleOrDefault();
         }
 
-        private Template<T, TResult> MergeTemplateGlobalFilter<T, TResult>(Template<T, TResult> template, bool ignoreGlobalFilters) where T : IEntity
+        private Template<T, TResult> MergeTemplateGlobalFilter<T, TResult>(Template<T, TResult> template, bool ignoreGlobalFilters)
         {
             //WARNING: this has to do the same thing as Logic.MergeGlobalFilter method
             //         if the following logic changes, update the other method also
diff --git a/MongoDB.Entities/DBContext/DBContext.Queryable.cs b/MongoDB.Entities/DBContext/DBContext.Queryable.cs
index cb79264ca..62e37d4ed 100644
--- a/MongoDB.Entities/DBContext/DBContext.Queryable.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Queryable.cs
@@ -13,7 +13,7 @@ public partial class DBContext
         /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
         /// <param name="collectionName"></param>
         /// <param name="collection"></param>
-        public IMongoQueryable<T> Queryable<T>(AggregateOptions? options = null, bool ignoreGlobalFilters = false, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
+        public IMongoQueryable<T> Queryable<T>(AggregateOptions? options = null, bool ignoreGlobalFilters = false, string? collectionName = null, IMongoCollection<T>? collection = null)
         {
             var globalFilter = Logic.MergeWithGlobalFilter(ignoreGlobalFilters, _globalFilters, Builders<T>.Filter.Empty);
             collection = Collection(collectionName, collection);
diff --git a/MongoDB.Entities/DBContext/DBContext.Replace.cs b/MongoDB.Entities/DBContext/DBContext.Replace.cs
index b831a2f90..e3a8712b8 100644
--- a/MongoDB.Entities/DBContext/DBContext.Replace.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Replace.cs
@@ -9,10 +9,13 @@ public partial class DBContext
         /// <para>TIP: Only the first matched entity will be replaced</para>
         /// </summary>
         /// <typeparam name="T">The type of entity</typeparam>
-        public Replace<T> Replace<T>(string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
+        /// <typeparam name="TId">ID type</typeparam>
+        public Replace<T, TId> Replace<T, TId>(string? collectionName = null, IMongoCollection<T>? collection = null)
+            where TId : IComparable<TId>, IEquatable<TId>
+            where T : IEntity<TId>
         {
             ThrowIfModifiedByIsEmpty<T>();
-            return new Replace<T>(this, Collection(collectionName, collection), OnBeforeSave<T>);
+            return new Replace<T, TId>(this, Collection(collectionName, collection), OnBeforeSave<T>);
         }
     }
 }
diff --git a/MongoDB.Entities/DBContext/DBContext.Save.cs b/MongoDB.Entities/DBContext/DBContext.Save.cs
index bde3f9848..7c6182a70 100644
--- a/MongoDB.Entities/DBContext/DBContext.Save.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Save.cs
@@ -17,25 +17,28 @@ public partial class DBContext
         /// If ID value is null, a new entity is created. If ID has a value, then existing entity is replaced.
         /// </summary>
         /// <typeparam name="T">The type of entity</typeparam>
+        /// <typeparam name="TId">ID type</typeparam>
         /// <param name="entity">The instance to persist</param>
         /// <param name="cancellation">And optional cancellation token</param>
         /// <param name="collectionName"></param>
         /// <param name="collection"></param>
-        public Task SaveAsync<T>(T entity, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
+        public Task SaveAsync<T, TId>(T entity, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null)
+            where TId : IComparable<TId>, IEquatable<TId>
+            where T : IEntity<TId>
         {
             SetModifiedBySingle(entity);
             OnBeforeSave(entity);
             collection = Collection(collectionName, collection);
-            if (PrepAndCheckIfInsert(entity))
+            if (PrepAndCheckIfInsert<T, TId>(entity))
             {
                 return Session is null
                        ? collection.InsertOneAsync(entity, null, cancellation)
                        : collection.InsertOneAsync(Session, entity, null, cancellation);
             }
-
+            var filter = Builders<T>.Filter.Eq(x => x.ID, entity.ID);
             return Session == null
-                   ? collection.ReplaceOneAsync(x => x.ID == entity.ID, entity, new ReplaceOptions { IsUpsert = true }, cancellation)
-                   : collection.ReplaceOneAsync(Session, x => x.ID == entity.ID, entity, new ReplaceOptions { IsUpsert = true }, cancellation);
+                   ? collection.ReplaceOneAsync(filter, entity, new ReplaceOptions { IsUpsert = true }, cancellation)
+                   : collection.ReplaceOneAsync(Session, filter, entity, new ReplaceOptions { IsUpsert = true }, cancellation);
         }
 
         /// <summary>
@@ -43,11 +46,14 @@ public Task SaveAsync<T>(T entity, CancellationToken cancellation = default, str
         /// If ID value is null, a new entity is created. If ID has a value, then existing entity is replaced.
         /// </summary>
         /// <typeparam name="T">The type of entity</typeparam>
+        /// <typeparam name="TId">ID type</typeparam>
         /// <param name="entities">The entities to persist</param>
         /// <param name="cancellation">And optional cancellation token</param>
         /// <param name="collectionName"></param>
         /// <param name="collection"></param>
-        public Task<BulkWriteResult<T>> SaveAsync<T>(IEnumerable<T> entities, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
+        public Task<BulkWriteResult<T>> SaveAsync<T, TId>(IEnumerable<T> entities, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null)
+             where TId : IComparable<TId>, IEquatable<TId>
+            where T : IEntity<TId>
         {
             SetModifiedByMultiple(entities);
             foreach (var ent in entities) OnBeforeSave(ent);
@@ -55,7 +61,7 @@ public Task<BulkWriteResult<T>> SaveAsync<T>(IEnumerable<T> entities, Cancellati
 
             var models = entities.Select<T, WriteModel<T>>(ent =>
             {
-                if (PrepAndCheckIfInsert(ent))
+                if (PrepAndCheckIfInsert<T, TId>(ent))
                 {
                     return new InsertOneModel<T>(ent);
                 }
@@ -80,16 +86,19 @@ public Task<BulkWriteResult<T>> SaveAsync<T>(IEnumerable<T> entities, Cancellati
         /// You can only specify root level properties with the expression.</para>
         /// </summary>
         /// <typeparam name="T">Any class that implements IEntity</typeparam>
+        /// <typeparam name="TId">ID type</typeparam>
         /// <param name="entity">The entity to save</param>
         /// <param name="members">x => new { x.PropOne, x.PropTwo }</param>
         /// <param name="cancellation">An optional cancellation token</param>
         /// <param name="collectionName"></param>
         /// <param name="collection"></param>
-        public Task<UpdateResult> SaveOnlyAsync<T>(T entity, Expression<Func<T, object>> members, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
+        public Task<UpdateResult> SaveOnlyAsync<T, TId>(T entity, Expression<Func<T, object>> members, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null)
+            where TId : IComparable<TId>, IEquatable<TId>
+            where T : IEntity<TId>
         {
             SetModifiedBySingle(entity);
             OnBeforeSave(entity);
-            return SavePartial(entity, members, cancellation, collectionName: collectionName, collection: collection);
+            return SavePartial<T, TId>(entity, members, cancellation, collectionName: collectionName, collection: collection);
 
         }
 
@@ -100,16 +109,19 @@ public Task<UpdateResult> SaveOnlyAsync<T>(T entity, Expression<Func<T, object>>
         /// You can only specify root level properties with the expression.</para>
         /// </summary>
         /// <typeparam name="T">Any class that implements IEntity</typeparam>
+        /// <typeparam name="TId">ID type</typeparam>
         /// <param name="entities">The batch of entities to save</param>
         /// <param name="members">x => new { x.PropOne, x.PropTwo }</param>
         /// <param name="cancellation">An optional cancellation token</param>
         /// <param name="collectionName"></param>
         /// <param name="collection"></param>
-        public Task<BulkWriteResult<T>> SaveOnlyAsync<T>(IEnumerable<T> entities, Expression<Func<T, object>> members, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
+        public Task<BulkWriteResult<T>> SaveOnlyAsync<T, TId>(IEnumerable<T> entities, Expression<Func<T, object>> members, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null)
+            where TId : IComparable<TId>, IEquatable<TId>
+            where T : IEntity<TId>
         {
             SetModifiedByMultiple(entities);
             foreach (var ent in entities) OnBeforeSave(ent);
-            return SavePartial(entities, members, cancellation, collectionName: collectionName, collection: collection);
+            return SavePartial<T, TId>(entities, members, cancellation, collectionName: collectionName, collection: collection);
         }
 
         /// <summary>
@@ -119,16 +131,19 @@ public Task<BulkWriteResult<T>> SaveOnlyAsync<T>(IEnumerable<T> entities, Expres
         /// You can only specify root level properties with the expression.</para>
         /// </summary>
         /// <typeparam name="T">Any class that implements IEntity</typeparam>
+        /// <typeparam name="TId">ID type</typeparam>
         /// <param name="entity">The entity to save</param>
         /// <param name="members">x => new { x.PropOne, x.PropTwo }</param>
         /// <param name="cancellation">An optional cancellation token</param>
         /// <param name="collectionName"></param>
         /// <param name="collection"></param>
-        public Task<UpdateResult> SaveExceptAsync<T>(T entity, Expression<Func<T, object>> members, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
+        public Task<UpdateResult> SaveExceptAsync<T, TId>(T entity, Expression<Func<T, object>> members, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null)
+            where TId : IComparable<TId>, IEquatable<TId>
+            where T : IEntity<TId>
         {
             SetModifiedBySingle(entity);
             OnBeforeSave(entity);
-            return SavePartial(entity, members, cancellation, true, collectionName: collectionName, collection: collection);
+            return SavePartial<T, TId>(entity, members, cancellation, true, collectionName: collectionName, collection: collection);
         }
 
         /// <summary>
@@ -138,16 +153,19 @@ public Task<UpdateResult> SaveExceptAsync<T>(T entity, Expression<Func<T, object
         /// You can only specify root level properties with the expression.</para>
         /// </summary>
         /// <typeparam name="T">Any class that implements IEntity</typeparam>
+        /// <typeparam name="TId">ID type</typeparam>
         /// <param name="entities">The batch of entities to save</param>
         /// <param name="members">x => new { x.PropOne, x.PropTwo }</param>
         /// <param name="cancellation">An optional cancellation token</param>
         /// <param name="collectionName"></param>
         /// <param name="collection"></param>
-        public Task<BulkWriteResult<T>> SaveExceptAsync<T>(IEnumerable<T> entities, Expression<Func<T, object>> members, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
+        public Task<BulkWriteResult<T>> SaveExceptAsync<T, TId>(IEnumerable<T> entities, Expression<Func<T, object>> members, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null)
+            where TId : IComparable<TId>, IEquatable<TId>
+            where T : IEntity<TId>
         {
             SetModifiedByMultiple(entities);
             foreach (var ent in entities) OnBeforeSave(ent);
-            return SavePartial(entities, members, cancellation, true, collectionName: collectionName, collection: collection);
+            return SavePartial<T, TId>(entities, members, cancellation, true, collectionName: collectionName, collection: collection);
         }
 
         /// <summary>
@@ -155,11 +173,14 @@ public Task<BulkWriteResult<T>> SaveExceptAsync<T>(IEnumerable<T> entities, Expr
         /// The properties to be excluded can be specified using the [Preserve] or [DontPreserve] attributes.
         /// </summary>
         /// <typeparam name="T">The type of entity</typeparam>
+        /// <typeparam name="TId">ID type</typeparam>
         /// <param name="entity">The entity to save</param>
         /// <param name="cancellation">An optional cancellation token</param>
         /// <param name="collectionName"></param>
         /// <param name="collection"></param>
-        public Task<UpdateResult> SavePreservingAsync<T>(T entity, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
+        public Task<UpdateResult> SavePreservingAsync<T, TId>(T entity, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null)
+            where TId : IComparable<TId>, IEquatable<TId>
+            where T : IEntity<TId>
         {
             SetModifiedBySingle(entity);
             OnBeforeSave(entity);
@@ -201,16 +222,18 @@ public Task<UpdateResult> SavePreservingAsync<T>(T entity, CancellationToken can
                     defs.Add(Builders<T>.Update.Set(p.Name, p.GetValue(entity)));
             }
 
+            var filter = Builders<T>.Filter.Eq(e => e.ID, entity.ID);
+            var update = Builders<T>.Update.Combine(defs);
             return
                 Session == null
-                ? Collection(collectionName, collection).UpdateOneAsync(e => e.ID == entity.ID, Builders<T>.Update.Combine(defs), _updateOptions, cancellation)
-                : Collection(collectionName, collection).UpdateOneAsync(Session, e => e.ID == entity.ID, Builders<T>.Update.Combine(defs), _updateOptions, cancellation);
+                ? Collection(collectionName, collection).UpdateOneAsync(filter, update, _updateOptions, cancellation)
+                : Collection(collectionName, collection).UpdateOneAsync(Session, filter, update, _updateOptions, cancellation);
         }
 
-        private void SetModifiedBySingle<T>(T entity) where T : IEntity
+        private void SetModifiedBySingle<T>(T entity)
         {
             var cache = Cache<T>();
-            if (cache.ModifiedByProp is null) 
+            if (cache.ModifiedByProp is null)
                 return;
             ThrowIfModifiedByIsEmpty<T>();
 
@@ -221,7 +244,7 @@ private void SetModifiedBySingle<T>(T entity) where T : IEntity
             //      to be able to correctly deserialize a user supplied derived/sub class of ModifiedOn.
         }
 
-        private void SetModifiedByMultiple<T>(IEnumerable<T> entities) where T : IEntity
+        private void SetModifiedByMultiple<T>(IEnumerable<T> entities)
         {
             var cache = Cache<T>();
             if (cache.ModifiedByProp is null)
diff --git a/MongoDB.Entities/DBContext/DBContext.Sequence.cs b/MongoDB.Entities/DBContext/DBContext.Sequence.cs
index 3d4f8f454..8ce89c474 100644
--- a/MongoDB.Entities/DBContext/DBContext.Sequence.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Sequence.cs
@@ -11,7 +11,7 @@ public partial class DBContext
         /// <typeparam name="T">The type of entity to get the next sequential number for</typeparam>
         /// <param name="cancellation">An optional cancellation token</param>
         /// <remarks>transaction support will not be added due to unpredictability with concurrency.</remarks>
-        public Task<ulong> NextSequentialNumberAsync<T>(CancellationToken cancellation = default) where T : IEntity
+        public Task<ulong> NextSequentialNumberAsync<T>(CancellationToken cancellation = default)
         {
             return NextSequentialNumberAsync(CollectionName<T>(), cancellation);
         }
@@ -24,7 +24,7 @@ public Task<ulong> NextSequentialNumberAsync<T>(CancellationToken cancellation =
         /// <remarks>transaction support will not be added due to unpredictability with concurrency.</remarks>
         public Task<ulong> NextSequentialNumberAsync(string sequenceName, CancellationToken cancellation = default)
         {
-            return new UpdateAndGet<SequenceCounter, ulong>(this, Collection<SequenceCounter>(), onUpdateAction: null, defs: null)
+            return new UpdateAndGet<SequenceCounter, string, ulong>(this, Collection<SequenceCounter>(), onUpdateAction: null, defs: null)
                 .Match(s => s.ID == sequenceName)
                 .Modify(b => b.Inc(s => s.Count, 1ul))
                 .Option(o => o.IsUpsert = true)
diff --git a/MongoDB.Entities/DBContext/DBContext.Transaction.cs b/MongoDB.Entities/DBContext/DBContext.Transaction.cs
index ed40c8710..8eb40b0a9 100644
--- a/MongoDB.Entities/DBContext/DBContext.Transaction.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Transaction.cs
@@ -20,14 +20,12 @@ public IClientSessionHandle Transaction(ClientSessionOptions? options = null)
         }
 
         /// <summary>
-        /// Creates a new DBContext and a new MongoServerContext and Starts a transaction on the new instance.        
+        /// Creates a new Transaction and a new MongoServerContext and Starts a transaction on the new instance.        
         /// </summary>
         /// <param name="options">Client session options for this transaction</param>
-        public DBContext TransactionCopy(ClientSessionOptions? options = null)
+        public Transaction TransactionCopy(ClientSessionOptions? options = null)
         {
-            var server = new MongoServerContext(MongoServerContext);
-            server.Transaction(options);
-            return new DBContext(server, Database, Options);
+            return new Transaction(MongoServerContext, Database.DatabaseNamespace.DatabaseName, options);
         }
 
         /// <summary>
diff --git a/MongoDB.Entities/DBContext/DBContext.Update.cs b/MongoDB.Entities/DBContext/DBContext.Update.cs
index 1e0bc984e..06114ed3a 100644
--- a/MongoDB.Entities/DBContext/DBContext.Update.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Update.cs
@@ -1,48 +1,53 @@
-using MongoDB.Driver;
-using System.Reflection;
+namespace MongoDB.Entities;
 
-namespace MongoDB.Entities
+public partial class DBContext
 {
-    public partial class DBContext
+    /// <summary>
+    /// Starts an update command for the given entity type
+    /// </summary>
+    /// <typeparam name="T">The type of entity</typeparam>
+    /// <typeparam name="TId">ID type</typeparam>
+    public Update<T, TId> Update<T, TId>(string? collectionName = null, IMongoCollection<T>? collection = null)
+        where TId : IComparable<TId>, IEquatable<TId>
+        where T : IEntity<TId>
     {
-        /// <summary>
-        /// Starts an update command for the given entity type
-        /// </summary>
-        /// <typeparam name="T">The type of entity</typeparam>
-        public Update<T> Update<T>(string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
+        var cmd = new Update<T, TId>(this, Collection(collectionName, collection), OnBeforeUpdate<T, TId, Update<T, TId>>);
+        if (Cache<T>().ModifiedByProp is PropertyInfo ModifiedByProp)
         {
-            var cmd = new Update<T>(this, Collection(collectionName, collection), OnBeforeUpdate<T, Update<T>>);
-            if (Cache<T>().ModifiedByProp is PropertyInfo ModifiedByProp)
-            {
-                ThrowIfModifiedByIsEmpty<T>();
-                cmd.Modify(b => b.Set(ModifiedByProp.Name, ModifiedBy));
-            }
-            return cmd;
+            ThrowIfModifiedByIsEmpty<T>();
+            cmd.Modify(b => b.Set(ModifiedByProp.Name, ModifiedBy));
         }
+        return cmd;
+    }
 
-        /// <summary>
-        /// Starts an update-and-get command for the given entity type
-        /// </summary>
-        /// <typeparam name="T">The type of entity</typeparam>
-        public UpdateAndGet<T> UpdateAndGet<T>(string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
-        {
-            return UpdateAndGet<T, T>(collectionName, collection);
-        }
+    /// <summary>
+    /// Starts an update-and-get command for the given entity type
+    /// </summary>
+    /// <typeparam name="T">The type of entity</typeparam>
+    /// <typeparam name="TId">ID type</typeparam>
+    public UpdateAndGet<T, TId> UpdateAndGet<T, TId>(string? collectionName = null, IMongoCollection<T>? collection = null)
+        where TId : IComparable<TId>, IEquatable<TId>
+        where T : IEntity<TId>
+    {
+        return UpdateAndGet<T, TId>(collectionName, collection);
+    }
 
-        /// <summary>
-        /// Starts an update-and-get command with projection support for the given entity type
-        /// </summary>
-        /// <typeparam name="T">The type of entity</typeparam>
-        /// <typeparam name="TProjection">The type of the end result</typeparam>
-        public UpdateAndGet<T, TProjection> UpdateAndGet<T, TProjection>(string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
+    /// <summary>
+    /// Starts an update-and-get command with projection support for the given entity type
+    /// </summary>
+    /// <typeparam name="T">The type of entity</typeparam>
+    /// <typeparam name="TProjection">The type of the end result</typeparam>
+    /// <typeparam name="TId">ID type</typeparam>
+    public UpdateAndGet<T, TId, TProjection> UpdateAndGet<T, TId, TProjection>(string? collectionName = null, IMongoCollection<T>? collection = null)
+         where TId : IComparable<TId>, IEquatable<TId>
+        where T : IEntity<TId>
+    {
+        var cmd = new UpdateAndGet<T, TId, TProjection>(this, Collection(collectionName, collection), OnBeforeUpdate<T, TId, UpdateAndGet<T, TId, TProjection>>);
+        if (Cache<T>().ModifiedByProp is PropertyInfo ModifiedByProp)
         {
-            var cmd = new UpdateAndGet<T, TProjection>(this, Collection(collectionName, collection), OnBeforeUpdate<T, UpdateAndGet<T, TProjection>>);
-            if (Cache<T>().ModifiedByProp is PropertyInfo ModifiedByProp)
-            {
-                ThrowIfModifiedByIsEmpty<T>();
-                cmd.Modify(b => b.Set(ModifiedByProp.Name, ModifiedBy));
-            }
-            return cmd;
+            ThrowIfModifiedByIsEmpty<T>();
+            cmd.Modify(b => b.Set(ModifiedByProp.Name, ModifiedBy));
         }
+        return cmd;
     }
 }
diff --git a/MongoDB.Entities/DBContext/DBContext.Watcher.cs b/MongoDB.Entities/DBContext/DBContext.Watcher.cs
index 451c0821f..0895c1147 100644
--- a/MongoDB.Entities/DBContext/DBContext.Watcher.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Watcher.cs
@@ -1,34 +1,30 @@
-using MongoDB.Driver;
-using System.Collections.Generic;
+namespace MongoDB.Entities;
 
-namespace MongoDB.Entities
+public partial class DBContext
 {
-    public partial class DBContext
+    /// <summary>
+    /// Retrieves the 'change-stream' watcher instance for a given unique name. 
+    /// If an instance for the name does not exist, it will return a new instance. 
+    /// If an instance already exists, that instance will be returned.
+    /// </summary>
+    /// <typeparam name="T">The entity type to get a watcher for</typeparam>
+    /// <param name="name">A unique name for the watcher of this entity type. Names can be duplicate among different entity types.</param>
+    /// <param name="collectionName"></param>
+    /// <param name="collection"></param>
+    public Watcher<T> Watcher<T>(string name, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
     {
-        /// <summary>
-        /// Retrieves the 'change-stream' watcher instance for a given unique name. 
-        /// If an instance for the name does not exist, it will return a new instance. 
-        /// If an instance already exists, that instance will be returned.
-        /// </summary>
-        /// <typeparam name="T">The entity type to get a watcher for</typeparam>
-        /// <param name="name">A unique name for the watcher of this entity type. Names can be duplicate among different entity types.</param>
-        /// <param name="collectionName"></param>
-        /// <param name="collection"></param>
-        public Watcher<T> Watcher<T>(string name, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
-        {
-            var cache = Cache<T>();
-            if (cache.Watchers.TryGetValue(name.ToLowerInvariant().Trim(), out Watcher<T> watcher))
-                return watcher;
-
-            watcher = new Watcher<T>(name.ToLowerInvariant().Trim(), this, Collection(collectionName, collection));
-            cache.Watchers.TryAdd(name, watcher);
+        var cache = Cache<T>();
+        if (cache.Watchers.TryGetValue(name.ToLowerInvariant().Trim(), out Watcher<T> watcher))
             return watcher;
-        }
 
-        /// <summary>
-        /// Returns all the watchers for a given entity type
-        /// </summary>
-        /// <typeparam name="T">The entity type to get the watcher of</typeparam>
-        public IEnumerable<Watcher<T>> Watchers<T>() where T : IEntity => Cache<T>().Watchers.Values;
+        watcher = new Watcher<T>(name.ToLowerInvariant().Trim(), Collection(collectionName, collection));
+        cache.Watchers.TryAdd(name, watcher);
+        return watcher;
     }
+
+    /// <summary>
+    /// Returns all the watchers for a given entity type
+    /// </summary>
+    /// <typeparam name="T">The entity type to get the watcher of</typeparam>
+    public IEnumerable<Watcher<T>> Watchers<T>() where T : IEntity => Cache<T>().Watchers.Values;
 }
diff --git a/MongoDB.Entities/DBContext/DBContext.cs b/MongoDB.Entities/DBContext/DBContext.cs
index 9a428e96e..f7866a585 100644
--- a/MongoDB.Entities/DBContext/DBContext.cs
+++ b/MongoDB.Entities/DBContext/DBContext.cs
@@ -169,8 +169,8 @@ public DBContext(ModifiedBy? modifiedBy = null) : this("default", modifiedBy: mo
     /// <summary>
     /// This event hook will be trigged right before an entity is persisted
     /// </summary>
-    /// <typeparam name="T">Any entity that implements IEntity</typeparam>
-    protected virtual void OnBeforeSave<T>(T entity) where T : IEntity
+    /// <typeparam name="T">Any entity</typeparam>    
+    protected virtual void OnBeforeSave<T>(T entity)
     {
     }
 
@@ -179,7 +179,11 @@ protected virtual void OnBeforeSave<T>(T entity) where T : IEntity
     /// </summary>
     /// <typeparam name="T">Any entity that implements IEntity</typeparam>
     /// <typeparam name="TSelf">Any entity that implements IEntity</typeparam>
-    protected virtual void OnBeforeUpdate<T, TSelf>(UpdateBase<T, TSelf> updateBase) where T : IEntity where TSelf : UpdateBase<T, TSelf>
+    /// <typeparam name="TId">ID type</typeparam>
+    protected virtual void OnBeforeUpdate<T, TId, TSelf>(UpdateBase<T, TId, TSelf> updateBase)
+        where T : IEntity<TId>
+        where TId : IComparable<TId>, IEquatable<TId>
+        where TSelf : UpdateBase<T, TId, TSelf>
     {
     }
 
@@ -191,7 +195,7 @@ protected virtual void OnBeforeUpdate<T, TSelf>(UpdateBase<T, TSelf> updateBase)
     /// <typeparam name="T">The type of Entity this global filter should be applied to</typeparam>
     /// <param name="filter">x => x.Prop1 == "some value"</param>
     /// <param name="prepend">Set to true if you want to prepend this global filter to your operation filters instead of being appended</param> 
-    protected void SetGlobalFilter<T>(Expression<Func<T, bool>> filter, bool prepend = false) where T : IEntity
+    protected void SetGlobalFilter<T>(Expression<Func<T, bool>> filter, bool prepend = false)
     {
         SetGlobalFilter(Builders<T>.Filter.Where(filter), prepend);
     }
@@ -202,7 +206,7 @@ protected void SetGlobalFilter<T>(Expression<Func<T, bool>> filter, bool prepend
     /// <typeparam name="T">The type of Entity this global filter should be applied to</typeparam>
     /// <param name="filter">b => b.Eq(x => x.Prop1, "some value")</param>
     /// <param name="prepend">Set to true if you want to prepend this global filter to your operation filters instead of being appended</param>
-    protected void SetGlobalFilter<T>(Func<FilterDefinitionBuilder<T>, FilterDefinition<T>> filter, bool prepend = false) where T : IEntity
+    protected void SetGlobalFilter<T>(Func<FilterDefinitionBuilder<T>, FilterDefinition<T>> filter, bool prepend = false)
     {
         SetGlobalFilter(filter(Builders<T>.Filter), prepend);
     }
@@ -213,7 +217,7 @@ protected void SetGlobalFilter<T>(Func<FilterDefinitionBuilder<T>, FilterDefinit
     /// <typeparam name="T">The type of Entity this global filter should be applied to</typeparam>
     /// <param name="filter">A filter definition to be applied</param>
     /// <param name="prepend">Set to true if you want to prepend this global filter to your operation filters instead of being appended</param>
-    protected void SetGlobalFilter<T>(FilterDefinition<T> filter, bool prepend = false) where T : IEntity
+    protected void SetGlobalFilter<T>(FilterDefinition<T> filter, bool prepend = false)
     {
         AddFilter(typeof(T), (filter, prepend));
     }
@@ -237,7 +241,7 @@ protected void SetGlobalFilter(Type type, string jsonString, bool prepend = fals
     /// <typeparam name="TBase">The type of the base class</typeparam>
     /// <param name="filter">b => b.Eq(x => x.Prop1, "some value")</param>
     /// <param name="prepend">Set to true if you want to prepend this global filter to your operation filters instead of being appended</param>
-    protected void SetGlobalFilterForBaseClass<TBase>(Expression<Func<TBase, bool>> filter, bool prepend = false) where TBase : IEntity
+    protected void SetGlobalFilterForBaseClass<TBase>(Expression<Func<TBase, bool>> filter, bool prepend = false)
     {
         SetGlobalFilterForBaseClass(Builders<TBase>.Filter.Where(filter), prepend);
     }
@@ -248,7 +252,7 @@ protected void SetGlobalFilterForBaseClass<TBase>(Expression<Func<TBase, bool>>
     /// <typeparam name="TBase">The type of the base class</typeparam>
     /// <param name="filter">b => b.Eq(x => x.Prop1, "some value")</param>
     /// <param name="prepend">Set to true if you want to prepend this global filter to your operation filters instead of being appended</param>
-    protected void SetGlobalFilterForBaseClass<TBase>(Func<FilterDefinitionBuilder<TBase>, FilterDefinition<TBase>> filter, bool prepend = false) where TBase : IEntity
+    protected void SetGlobalFilterForBaseClass<TBase>(Func<FilterDefinitionBuilder<TBase>, FilterDefinition<TBase>> filter, bool prepend = false)
     {
         SetGlobalFilterForBaseClass(filter(Builders<TBase>.Filter), prepend);
     }
@@ -259,7 +263,7 @@ protected void SetGlobalFilterForBaseClass<TBase>(Func<FilterDefinitionBuilder<T
     /// <typeparam name="TBase">The type of the base class</typeparam>
     /// <param name="filter">A filter definition to be applied</param>
     /// <param name="prepend">Set to true if you want to prepend this global filter to your operation filters instead of being appended</param>
-    protected void SetGlobalFilterForBaseClass<TBase>(FilterDefinition<TBase> filter, bool prepend = false) where TBase : IEntity
+    protected void SetGlobalFilterForBaseClass<TBase>(FilterDefinition<TBase> filter, bool prepend = false)
     {
         foreach (var entType in MongoServerContext.AllEntitiyTypes.Where(t => t.IsSubclassOf(typeof(TBase))))
         {
@@ -293,7 +297,7 @@ protected void SetGlobalFilterForInterface<TInterface>(string jsonString, bool p
 
 
 
-    private void ThrowIfModifiedByIsEmpty<T>() where T : IEntity
+    private void ThrowIfModifiedByIsEmpty<T>()
     {
         var cache = Cache<T>();
         if (cache.ModifiedByProp is not null && ModifiedBy is null)
@@ -310,20 +314,23 @@ private void AddFilter(Type type, (object filterDef, bool prepend) filter)
 
 
     private readonly ConcurrentDictionary<Type, Cache> _cache = new();
-    internal EntityCache<T> Cache<T>() where T : IEntity
+
+    internal EntityCache<T> Cache<T>()
     {
-        if (!_cache.TryGetValue(typeof(T), out var c))
+        var type = typeof(T);
+        if (!_cache.TryGetValue(type, out var c))
         {
-            c = new EntityCache<T>();
+            _cache[type] = c = EntityCache<T>.Default;
         }
         return (EntityCache<T>)c;
     }
-    public virtual string CollectionName<T>() where T : IEntity
+
+    public virtual string CollectionName<T>()
     {
         return Cache<T>().CollectionName;
     }
 
-    public virtual IMongoCollection<T> Collection<T>(string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
+    public virtual IMongoCollection<T> Collection<T>(string? collectionName = null, IMongoCollection<T>? collection = null)
     {
         return collection ?? GetCollection<T>(collectionName ?? CollectionName<T>());
     }
diff --git a/MongoDB.Entities/Extensions/Entity.cs b/MongoDB.Entities/Extensions/Entity.cs
index c0ddf3fb2..388b0dc09 100644
--- a/MongoDB.Entities/Extensions/Entity.cs
+++ b/MongoDB.Entities/Extensions/Entity.cs
@@ -30,13 +30,12 @@ private static T Duplicate<T>(this T source)
                 ).Data;
         }
 
-        internal static void ThrowIfUnsaved(this string? entityID)
+        internal static void ThrowIfUnsaved<TId>(this TId? id) where TId : IComparable<TId>, IEquatable<TId>
         {
-            if (string.IsNullOrWhiteSpace(entityID))
+            if ((id is string strId && string.IsNullOrWhiteSpace(strId)) || EqualityComparer<TId?>.Default.Equals(id, default))
                 throw new InvalidOperationException("Please save the entity before performing this operation!");
         }
-
-        internal static void ThrowIfUnsaved(this IEntity entity)
+        internal static void ThrowIfUnsaved<TId>(this IEntity<TId> entity) where TId : IComparable<TId>, IEquatable<TId>
         {
             ThrowIfUnsaved(entity.ID);
         }
@@ -78,7 +77,7 @@ public static string FullPath<T>(this Expression<Func<T, object>> expression)
         /// </summary>
         public static IMongoQueryable<T> Queryable<T>(this T _, AggregateOptions? options = null, string tenantPrefix = null) where T : IEntity
         {
-            return DB.Queryable<T>(options, tenantPrefix: tenantPrefix);
+            return DB.Queryable<T>(options);
         }
 
         /// <summary>
diff --git a/MongoDB.Entities/GlobalUsing.cs b/MongoDB.Entities/GlobalUsing.cs
new file mode 100644
index 000000000..31b77f63a
--- /dev/null
+++ b/MongoDB.Entities/GlobalUsing.cs
@@ -0,0 +1,8 @@
+global using MongoDB.Driver;
+global using System.Linq.Expressions;
+global using MongoDB.Bson;
+global using MongoDB.Bson.Serialization;
+global using MongoDB.Bson.Serialization.Attributes;
+global using MongoDB.Bson.Serialization.Serializers;
+global using MongoDB.Driver.Linq;
+global using System.Reflection;
diff --git a/MongoDB.Entities/MongoDB.Entities.csproj b/MongoDB.Entities/MongoDB.Entities.csproj
index fe0c9639b..50395ab3c 100644
--- a/MongoDB.Entities/MongoDB.Entities.csproj
+++ b/MongoDB.Entities/MongoDB.Entities.csproj
@@ -27,7 +27,10 @@
 		<PackageReadmeFile>README.md</PackageReadmeFile>
 		<PackageTags>mongodb mongodb-orm mongodb-repo mongodb-repository entities nosql orm linq netcore repository aspnetcore netcore2 netcore3 dotnetstandard database persistance dal repo</PackageTags>
 		<GenerateDocumentationFile>true</GenerateDocumentationFile>
+	</PropertyGroup>
+	<PropertyGroup>
 		<LangVersion>latest</LangVersion>
+		<ImplicitUsings>enable</ImplicitUsings>
 	</PropertyGroup>
 
 	<PropertyGroup>
diff --git a/MongoDB.Entities/Relationships/JoinRecord.cs b/MongoDB.Entities/Relationships/JoinRecord.cs
index 2611c256b..2f253f1a4 100644
--- a/MongoDB.Entities/Relationships/JoinRecord.cs
+++ b/MongoDB.Entities/Relationships/JoinRecord.cs
@@ -1,21 +1,30 @@
-namespace MongoDB.Entities
+using MongoDB.Bson.Serialization.Attributes;
+using System;
+
+namespace MongoDB.Entities;
+
+/// <summary>
+/// Represents a parent-child relationship between two entities.
+/// <para>TIP: The ParentID and ChildID switches around for many-to-many relationships depending on the side of the relationship you're accessing.</para>
+/// </summary>
+public class JoinRecord<TId1, TId2> : Entity<(TId1 ParentID, TId2 ChildID)>
 {
-    /// <summary>
-    /// Represents a parent-child relationship between two entities.
-    /// <para>TIP: The ParentID and ChildID switches around for many-to-many relationships depending on the side of the relationship you're accessing.</para>
-    /// </summary>
-    public class JoinRecord : Entity
-    {
-        /// <summary>
-        /// The ID of the parent IEntity for both one-to-many and the owner side of many-to-many relationships.
-        /// </summary>
-        [AsObjectId]
-        public string ParentID { get; set; } = null!;
+    ///// <summary>
+    ///// The ID of the parent IEntity for both one-to-many and the owner side of many-to-many relationships.
+    ///// </summary>
+    //[BsonIgnore]
+    //public string ParentID { get; set; } = null!;
 
-        /// <summary>
-        /// The ID of the child IEntity in one-to-many relationships and the ID of the inverse side IEntity in many-to-many relationships.
-        /// </summary>
-        [AsObjectId]
-        public string ChildID { get; set; } = null!;
+    ///// <summary>
+    ///// The ID of the child IEntity in one-to-many relationships and the ID of the inverse side IEntity in many-to-many relationships.
+    ///// </summary>
+    //[AsObjectId]
+    //public string ChildID { get; set; } = null!;
+
+
+    public override (TId1 ParentID, TId2 ChildID) GenerateNewID()
+    {
+        //the caller is responsible for assigning ids
+        throw new NotImplementedException();
     }
 }
diff --git a/MongoDB.Entities/Relationships/Many.Queryable.cs b/MongoDB.Entities/Relationships/Many.Queryable.cs
index c7c28fb7f..26b0f392e 100644
--- a/MongoDB.Entities/Relationships/Many.Queryable.cs
+++ b/MongoDB.Entities/Relationships/Many.Queryable.cs
@@ -5,148 +5,147 @@
 using System.Collections.Generic;
 using System.Linq;
 
-namespace MongoDB.Entities
+namespace MongoDB.Entities;
+
+public sealed partial class Many<TChild> : IEnumerable<TChild> where TChild : IEntity
 {
-    public sealed partial class Many<TChild> : IEnumerable<TChild> where TChild : IEntity
+    /// <summary>
+    /// An IQueryable of JoinRecords for this relationship
+    /// </summary>
+    /// <param name="session">An optional session if using within a transaction</param>
+    /// <param name="options">An optional AggregateOptions object</param>
+    public IMongoQueryable<JoinRecord> JoinQueryable(IClientSessionHandle session = null, AggregateOptions options = null)
+    {
+        return session == null
+               ? JoinCollection.AsQueryable(options)
+               : JoinCollection.AsQueryable(session, options);
+    }
+
+    /// <summary>
+    /// Get an IQueryable of parents matching a single child ID for this relationship.
+    /// </summary>
+    /// <typeparam name="TParent">The type of the parent IEntity</typeparam>
+    /// <param name="childID">A child ID</param>
+    /// <param name="session">An optional session if using within a transaction</param>
+    /// <param name="options">An optional AggregateOptions object</param>
+    public IMongoQueryable<TParent> ParentsQueryable<TParent>(string childID, IClientSessionHandle session = null, AggregateOptions options = null) where TParent : IEntity
+    {
+        return ParentsQueryable<TParent>(new[] { childID }, session, options);
+    }
+
+    /// <summary>
+    /// Get an IQueryable of parents matching multiple child IDs for this relationship.
+    /// </summary>
+    /// <typeparam name="TParent">The type of the parent IEntity</typeparam>
+    /// <param name="childIDs">An IEnumerable of child IDs</param>
+    /// <param name="session">An optional session if using within a transaction</param>
+    /// <param name="options">An optional AggregateOptions object</param>
+    public IMongoQueryable<TParent> ParentsQueryable<TParent>(IEnumerable<string> childIDs, IClientSessionHandle session = null, AggregateOptions options = null) where TParent : IEntity
     {
-        /// <summary>
-        /// An IQueryable of JoinRecords for this relationship
-        /// </summary>
-        /// <param name="session">An optional session if using within a transaction</param>
-        /// <param name="options">An optional AggregateOptions object</param>
-        public IMongoQueryable<JoinRecord> JoinQueryable(IClientSessionHandle session = null, AggregateOptions options = null)
+        if (typeof(TParent) == typeof(TChild)) throw new InvalidOperationException("Both parent and child types cannot be the same");
+
+        if (isInverse)
         {
-            return session == null
-                   ? JoinCollection.AsQueryable(options)
-                   : JoinCollection.AsQueryable(session, options);
+            return JoinQueryable(session, options)
+                   .Where(j => childIDs.Contains(j.ParentID))
+                   .Join(
+                       DB.Collection<TParent>(null),
+                       j => j.ChildID,
+                       p => p.ID,
+                       (_, p) => p)
+                   .Distinct();
         }
-
-        /// <summary>
-        /// Get an IQueryable of parents matching a single child ID for this relationship.
-        /// </summary>
-        /// <typeparam name="TParent">The type of the parent IEntity</typeparam>
-        /// <param name="childID">A child ID</param>
-        /// <param name="session">An optional session if using within a transaction</param>
-        /// <param name="options">An optional AggregateOptions object</param>
-        public IMongoQueryable<TParent> ParentsQueryable<TParent>(string childID, IClientSessionHandle session = null, AggregateOptions options = null) where TParent : IEntity
+        else
         {
-            return ParentsQueryable<TParent>(new[] { childID }, session, options);
+            return JoinQueryable(session, options)
+                   .Where(j => childIDs.Contains(j.ChildID))
+                   .Join(
+                       DB.Collection<TParent>(null),
+                       j => j.ParentID,
+                       p => p.ID,
+                       (_, p) => p)
+                   .Distinct();
         }
+    }
 
-        /// <summary>
-        /// Get an IQueryable of parents matching multiple child IDs for this relationship.
-        /// </summary>
-        /// <typeparam name="TParent">The type of the parent IEntity</typeparam>
-        /// <param name="childIDs">An IEnumerable of child IDs</param>
-        /// <param name="session">An optional session if using within a transaction</param>
-        /// <param name="options">An optional AggregateOptions object</param>
-        public IMongoQueryable<TParent> ParentsQueryable<TParent>(IEnumerable<string> childIDs, IClientSessionHandle session = null, AggregateOptions options = null) where TParent : IEntity
-        {
-            if (typeof(TParent) == typeof(TChild)) throw new InvalidOperationException("Both parent and child types cannot be the same");
+    /// <summary>
+    /// Get an IQueryable of parents matching a supplied IQueryable of children for this relationship.
+    /// </summary>
+    /// <typeparam name="TParent">The type of the parent IEntity</typeparam>
+    /// <param name="children">An IQueryable of children</param>
+    /// <param name="session">An optional session if using within a transaction</param>
+    /// <param name="options">An optional AggregateOptions object</param>
+    public IMongoQueryable<TParent> ParentsQueryable<TParent>(IMongoQueryable<TChild> children, IClientSessionHandle session = null, AggregateOptions options = null) where TParent : IEntity
+    {
+        if (typeof(TParent) == typeof(TChild)) throw new InvalidOperationException("Both parent and child types cannot be the same");
 
-            if (isInverse)
-            {
-                return JoinQueryable(session, options)
-                       .Where(j => childIDs.Contains(j.ParentID))
-                       .Join(
-                           DB.Collection<TParent>(null),
-                           j => j.ChildID,
-                           p => p.ID,
-                           (_, p) => p)
-                       .Distinct();
-            }
-            else
-            {
-                return JoinQueryable(session, options)
-                       .Where(j => childIDs.Contains(j.ChildID))
-                       .Join(
-                           DB.Collection<TParent>(null),
-                           j => j.ParentID,
-                           p => p.ID,
-                           (_, p) => p)
-                       .Distinct();
-            }
+        if (isInverse)
+        {
+            return children
+                    .Join(
+                        JoinQueryable(session, options),
+                        c => c.ID,
+                        j => j.ParentID,
+                        (_, j) => j)
+                    .Join(
+                        DB.Collection<TParent>(null),
+                        j => j.ChildID,
+                        p => p.ID,
+                        (_, p) => p)
+                    .Distinct();
         }
-
-        /// <summary>
-        /// Get an IQueryable of parents matching a supplied IQueryable of children for this relationship.
-        /// </summary>
-        /// <typeparam name="TParent">The type of the parent IEntity</typeparam>
-        /// <param name="children">An IQueryable of children</param>
-        /// <param name="session">An optional session if using within a transaction</param>
-        /// <param name="options">An optional AggregateOptions object</param>
-        public IMongoQueryable<TParent> ParentsQueryable<TParent>(IMongoQueryable<TChild> children, IClientSessionHandle session = null, AggregateOptions options = null) where TParent : IEntity
+        else
         {
-            if (typeof(TParent) == typeof(TChild)) throw new InvalidOperationException("Both parent and child types cannot be the same");
-
-            if (isInverse)
-            {
-                return children
-                        .Join(
-                            JoinQueryable(session, options),
-                            c => c.ID,
-                            j => j.ParentID,
-                            (_, j) => j)
-                        .Join(
-                            DB.Collection<TParent>(null),
-                            j => j.ChildID,
-                            p => p.ID,
-                            (_, p) => p)
-                        .Distinct();
-            }
-            else
-            {
-                return children
-                       .Join(
-                            JoinQueryable(session, options),
-                            c => c.ID,
-                            j => j.ChildID,
-                            (_, j) => j)
-                       .Join(
-                            DB.Collection<TParent>(null),
-                            j => j.ParentID,
-                            p => p.ID,
-                            (_, p) => p)
-                       .Distinct();
-            }
+            return children
+                   .Join(
+                        JoinQueryable(session, options),
+                        c => c.ID,
+                        j => j.ChildID,
+                        (_, j) => j)
+                   .Join(
+                        DB.Collection<TParent>(null),
+                        j => j.ParentID,
+                        p => p.ID,
+                        (_, p) => p)
+                   .Distinct();
         }
+    }
 
-        /// <summary>
-        /// An IQueryable of child Entities for the parent.
-        /// </summary>
-        /// <param name="session">An optional session if using within a transaction</param>
-        /// <param name="options">An optional AggregateOptions object</param>
-        public IMongoQueryable<TChild> ChildrenQueryable(IClientSessionHandle session = null, AggregateOptions options = null)
-        {
-            parent.ThrowIfUnsaved();
+    /// <summary>
+    /// An IQueryable of child Entities for the parent.
+    /// </summary>
+    /// <param name="session">An optional session if using within a transaction</param>
+    /// <param name="options">An optional AggregateOptions object</param>
+    public IMongoQueryable<TChild> ChildrenQueryable(IClientSessionHandle session = null, AggregateOptions options = null)
+    {
+        parent.ThrowIfUnsaved();
 
-            if (isInverse)
-            {
-                return JoinQueryable(session, options)
-                       .Where(j => j.ChildID == parent.ID)
-                       .Join(
-                           DB.Collection<TChild>(null),
-                           j => j.ParentID,
-                           c => c.ID,
-                           (_, c) => c);
-            }
-            else
-            {
-                return JoinQueryable(session, options)
-                       .Where(j => j.ParentID == parent.ID)
-                       .Join(
-                           DB.Collection<TChild>(null),
-                           j => j.ChildID,
-                           c => c.ID,
-                           (_, c) => c);
-            }
+        if (isInverse)
+        {
+            return JoinQueryable(session, options)
+                   .Where(j => j.ChildID == parent.ID)
+                   .Join(
+                       DB.Collection<TChild>(null),
+                       j => j.ParentID,
+                       c => c.ID,
+                       (_, c) => c);
+        }
+        else
+        {
+            return JoinQueryable(session, options)
+                   .Where(j => j.ParentID == parent.ID)
+                   .Join(
+                       DB.Collection<TChild>(null),
+                       j => j.ChildID,
+                       c => c.ID,
+                       (_, c) => c);
         }
+    }
 
-        /// <inheritdoc/>
-        public IEnumerator<TChild> GetEnumerator() => ChildrenQueryable().GetEnumerator();
+    /// <inheritdoc/>
+    public IEnumerator<TChild> GetEnumerator() => ChildrenQueryable().GetEnumerator();
 
-        /// <inheritdoc/>
-        IEnumerator IEnumerable.GetEnumerator() => ChildrenQueryable().GetEnumerator();
+    /// <inheritdoc/>
+    IEnumerator IEnumerable.GetEnumerator() => ChildrenQueryable().GetEnumerator();
 
-    }
 }
diff --git a/MongoDB.Entities/Relationships/Many.cs b/MongoDB.Entities/Relationships/Many.cs
index ee5493d96..9d49933d1 100644
--- a/MongoDB.Entities/Relationships/Many.cs
+++ b/MongoDB.Entities/Relationships/Many.cs
@@ -27,7 +27,10 @@ public abstract class ManyBase
 /// </summary>
 /// <see cref="JoinRecord"/>
 /// <typeparam name="TChild">Type of the child IEntity.</typeparam>
-public sealed partial class Many<TChild> : ManyBase where TChild : IEntity
+/// <typeparam name="TChildId">Child Id type.</typeparam>
+public sealed partial class Many<TChild, TChildId> : ManyBase
+    where TChildId : IComparable<TChildId>, IEquatable<TChildId>
+    where TChild : IEntity<TChildId>
 {
     private static readonly BulkWriteOptions unOrdBlkOpts = new() { IsOrdered = false };
     private bool isInverse;
diff --git a/MongoDB.Entities/Relationships/NewMany.cs b/MongoDB.Entities/Relationships/NewMany.cs
index e2a98d641..b757feb51 100644
--- a/MongoDB.Entities/Relationships/NewMany.cs
+++ b/MongoDB.Entities/Relationships/NewMany.cs
@@ -1,13 +1,4 @@
-using MongoDB.Driver;
-using MongoDB.Driver.Linq;
-using System;
-using System.Collections.Generic;
-using System.Linq.Expressions;
-using System.Reflection;
-using System.Text;
-
-namespace MongoDB.Entities.NewMany;
-
+namespace MongoDB.Entities.NewMany;
 
 /*    
  results in the following:
@@ -45,43 +36,94 @@ namespace MongoDB.Entities.NewMany;
  * Add C to the Many list in B
  * Add an arbitrary join record
  */
-class A : Entity
+//class A : Entity
+//{
+//    public One<B, ObjectId>? SingleB1 { get; set; }
+//    public One<B, ObjectId>? SingleB2 { get; set; }
+//}
+//class B : Entity<ObjectId>
+//{
+//    public IManyS<A> ManyAVia1 { get; set; }
+//    public IManyS<A> ManyAVia2 { get; set; }
+
+//    [OwnerSide]
+//    public IMany<C, Guid> ManyC { get; set; }
+
+//    public B()
+//    {
+//        ManyAVia1 = (IManyS<A>)this.InitManyToOne(x => x.ManyAVia1, x => x.SingleB1);
+//        ManyAVia2 = (IManyS<A>)this.InitManyToOne(x => x.ManyAVia2, x => x.SingleB2);
+//        ManyC = this.InitManyToMany(x => x.ManyC, x => x.ManyB);
+//    }
+
+//    public override ObjectId GenerateNewID()
+//    {
+//        return ObjectId.GenerateNewId();
+//    }
+//}
+//class C : Entity<Guid>
+//{
+//    [InverseSide]
+//    public IMany<B, ObjectId> ManyB { get; set; }
+
+//    public C()
+//    {
+//        ManyB = this.InitManyToMany(c => c.ManyB, b => b.ManyC);
+//    }
+
+//    public override Guid GenerateNewID() => Guid.NewGuid();
+//}
+
+public interface IManyS<TChild> : IMany<TChild, string>
+    where TChild : IEntity
 {
-    public One<B>? SingleB1 { get; set; }
-    public One<B>? SingleB2 { get; set; }
+
 }
-class B : Entity
+public interface IMany<TChild, TChildId>
+    where TChild : IEntity<TChildId>
+    where TChildId : IComparable<TChildId>, IEquatable<TChildId>
 {
-    public Many<A> ManyAVia1 { get; set; }
-    public Many<A> ManyAVia2 { get; set; }
+    Find<TChild, TChildId, TChild> GetChildrenFind(DBContext context, string? childCollectionName = null, IMongoCollection<TChild>? collection = null);
+    Find<TChild, TChildId, TProjection> GetChildrenFind<TProjection>(DBContext context, string? childCollectionName = null, IMongoCollection<TChild>? collection = null);
+    IMongoQueryable<TChild> GetChildrenQuery(DBContext context, string? childCollectionName = null, IMongoCollection<TChild>? collection = null);
+}
 
-    [OwnerSide]
-    public Many<C> ManyC { get; set; }
+public interface IMany<TParent, TParentId, TChild, TChildId> : IMany<TChild, TChildId>
+    where TParent : IEntity<TParentId>
+    where TParentId : IComparable<TParentId>, IEquatable<TParentId>
+    where TChild : IEntity<TChildId>
+    where TChildId : IComparable<TChildId>, IEquatable<TChildId>
+{
+    TParent Parent { get; }
 
-    public B()
-    {
-        ManyAVia1 = this.InitManyToOne(x => x.ManyAVia1, x => x.SingleB1);
-        ManyAVia2 = this.InitManyToOne(x => x.ManyAVia2, x => x.SingleB2);
+    FilterDefinition<TChild> GetFilterForSingleDocument();
+}
 
-        ManyC = this.InitManyToMany(x => x.ManyC, x => x.ManyB);
-    }
+public interface IManyToMany<TParent, TParentId, TChild, TChildId> : IMany<TParent, TParentId, TChild, TChildId>
+    where TParent : IEntity<TParentId>
+    where TParentId : IComparable<TParentId>, IEquatable<TParentId>
+    where TChild : IEntity<TChildId>
+    where TChildId : IComparable<TChildId>, IEquatable<TChildId>
+{
+    bool IsParentOwner { get; }
 }
-class C : Entity
+public interface IManyToOne<TParent, TParentId, TChild, TChildId> : IMany<TParent, TParentId, TChild, TChildId>
+    where TParent : IEntity<TParentId>
+    where TParentId : IComparable<TParentId>, IEquatable<TParentId>
+    where TChild : IEntity<TChildId>
+    where TChildId : IComparable<TChildId>, IEquatable<TChildId>
 {
-    [InverseSide]
-    public Many<B> ManyB { get; set; }
-
-    public C()
-    {
-        ManyB = this.InitManyToMany(x => x.ManyB, x => x.ManyC);
-    }
 }
 
+
 /// <summary>
 /// Marker class
 /// </summary>
 /// <typeparam name="TChild"></typeparam>
-public abstract class Many<TChild> where TChild : IEntity
+/// <typeparam name="TChildId"></typeparam>
+public abstract class Many<TChild, TChildId> : IMany<TChild, TChildId>
+    where TChildId : IComparable<TChildId>, IEquatable<TChildId>
+    where TChild : IEntity<TChildId>
 {
     protected Many(PropertyInfo parentProperty, PropertyInfo childProperty)
     {
@@ -93,10 +135,14 @@ protected Many(PropertyInfo parentProperty, PropertyInfo childProperty)
     internal PropertyInfo ChildProperty { get; }
 
     public abstract IMongoQueryable<TChild> GetChildrenQuery(DBContext context, string? childCollectionName = null, IMongoCollection<TChild>? collection = null);
-    public Find<TChild, TChild> GetChildrenFind(DBContext context, string? childCollectionName = null, IMongoCollection<TChild>? collection = null) => GetChildrenFind<TChild>(context, childCollectionName, collection);
-    public abstract Find<TChild, TProjection> GetChildrenFind<TProjection>(DBContext context, string? childCollectionName = null, IMongoCollection<TChild>? collection = null);
+    public Find<TChild, TChildId, TChild> GetChildrenFind(DBContext context, string? childCollectionName = null, IMongoCollection<TChild>? collection = null) => GetChildrenFind<TChild>(context, childCollectionName, collection);
+    public abstract Find<TChild, TChildId, TProjection> GetChildrenFind<TProjection>(DBContext context, string? childCollectionName = null, IMongoCollection<TChild>? collection = null);
 }
-public abstract class Many<TParent, TChild> : Many<TChild> where TParent : IEntity where TChild : IEntity
+public abstract class Many<TParent, TParentId, TChild, TChildId> : Many<TChild, TChildId>, IMany<TParent, TParentId, TChild, TChildId>
+    where TParent : IEntity<TParentId>
+    where TParentId : IComparable<TParentId>, IEquatable<TParentId>
+    where TChild : IEntity<TChildId>
+    where TChildId : IComparable<TChildId>, IEquatable<TChildId>
 {
     public TParent Parent { get; }
     protected Many(TParent parent, PropertyInfo parentProperty, PropertyInfo childProperty) : base(parentProperty, childProperty)
@@ -107,7 +153,12 @@ protected Many(TParent parent, PropertyInfo parentProperty, PropertyInfo childPr
 
 
 }
-public sealed class ManyToMany<TParent, TChild> : Many<TParent, TChild> where TParent : IEntity where TChild : IEntity
+
+public sealed class ManyToMany<TParent, TParentId, TChild, TChildId> : Many<TParent, TParentId, TChild, TChildId>, IManyToMany<TParent, TParentId, TChild, TChildId>
+    where TParent : IEntity<TParentId>
+    where TParentId : IComparable<TParentId>, IEquatable<TParentId>
+    where TChild : IEntity<TChildId>
+    where TChildId : IComparable<TChildId>, IEquatable<TChildId>
 {
     public ManyToMany(bool isParentOwner, TParent parent, PropertyInfo parentProperty, PropertyInfo childProperty) : base(parent, parentProperty, childProperty)
     {
@@ -116,7 +167,7 @@ public ManyToMany(bool isParentOwner, TParent parent, PropertyInfo parentPropert
 
     public bool IsParentOwner { get; }
 
-    public override Find<TChild, TProjection> GetChildrenFind<TProjection>(DBContext context, string? childCollectionName = null, IMongoCollection<TChild>? collection = null)
+    public override Find<TChild, TChildId, TProjection> GetChildrenFind<TProjection>(DBContext context, string? childCollectionName = null, IMongoCollection<TChild>? collection = null)
     {
         throw new NotImplementedException();
     }
@@ -127,15 +178,19 @@ public override IMongoQueryable<TChild> GetChildrenQuery(DBContext context, stri
     }
 }
 
-public sealed class ManyToOne<TParent, TChild> : Many<TParent, TChild> where TParent : IEntity where TChild : IEntity
+public sealed class ManyToOne<TParent, TParentId, TChild, TChildId> : Many<TParent, TParentId, TChild, TChildId>, IManyToOne<TParent, TParentId, TChild, TChildId>
+    where TParent : IEntity<TParentId>
+    where TParentId : IComparable<TParentId>, IEquatable<TParentId>
+    where TChild : IEntity<TChildId>
+    where TChildId : IComparable<TChildId>, IEquatable<TChildId>
 {
     public ManyToOne(TParent parent, PropertyInfo parentProperty, PropertyInfo childProperty) : base(parent, parentProperty, childProperty)
     {
     }
 
-    public override Find<TChild, TProjection> GetChildrenFind<TProjection>(DBContext context, string? childCollectionName = null, IMongoCollection<TChild>? childCollection = null)
+    public override Find<TChild, TChildId, TProjection> GetChildrenFind<TProjection>(DBContext context, string? childCollectionName = null, IMongoCollection<TChild>? childCollection = null)
     {
-        return context.Find<TChild, TProjection>(childCollectionName, childCollection)
+        return context.Find<TChild, TChildId, TProjection>(childCollectionName, childCollection)
             .Match(GetFilterForSingleDocument()); //BRef==Parent.Id
     }
 
@@ -144,7 +199,6 @@ public override IMongoQueryable<TChild> GetChildrenQuery(DBContext context, stri
         return context.Queryable(collectionName: childCollectionName, collection: childCollection)
              .Where(_ => GetFilterForSingleDocument().Inject());
     }
-
 }
 
 
@@ -175,7 +229,11 @@ public static PropertyInfo GetPropertyInfo<TSource, TProperty>(this Expression<F
         return propInfo;
     }
 
-    public static ManyToMany<TParent, TChild> InitManyToMany<TParent, TChild>(this TParent parent, Expression<Func<TParent, Many<TChild>>> propertyExpression, Expression<Func<TChild, Many<TParent>>> propertyOtherSide) where TParent : IEntity where TChild : IEntity
+    public static IManyToMany<TParent, TParentId, TChild, TChildId> InitManyToMany<TParent, TParentId, TChild, TChildId>(this TParent parent, Expression<Func<TParent, IMany<TChild, TChildId>>> propertyExpression, Expression<Func<TChild, IMany<TParent, TParentId>>> propertyOtherSide)
+        where TParent : IEntity<TParentId>
+        where TParentId : IComparable<TParentId>, IEquatable<TParentId>
+        where TChild : IEntity<TChildId>
+        where TChildId : IComparable<TChildId>, IEquatable<TChildId>
     {
         var property = propertyExpression.GetPropertyInfo();
         var hasOwnerAttrib = property.IsDefined(typeof(OwnerSideAttribute), false);
@@ -190,17 +248,20 @@ public static ManyToMany<TParent, TChild> InitManyToMany<TParent, TChild>(this T
         if (!osHasOwnerAttrib && !osHasInverseAttrib) throw new InvalidOperationException("Missing attribute for determining relationship side of a many-to-many relationship");
 
         if ((hasOwnerAttrib == osHasOwnerAttrib) || (hasInverseAttrib == osHasInverseAttrib)) throw new InvalidOperationException("Both sides of the relationship cannot have the same attribute");
-        var res = new ManyToMany<TParent, TChild>(hasInverseAttrib, parent, property, osProperty);
+        var res = new ManyToMany<TParent, TParentId, TChild, TChildId>(hasInverseAttrib, parent, property, osProperty);
         //should we set the property ourself or let the user handle it ?
         //property.SetValue(parent, res);
         return res;
     }
-    public static ManyToOne<TParent, TChild> InitManyToOne<TParent, TChild>(this TParent parent, Expression<Func<TParent, Many<TChild>>> propertyExpression, Expression<Func<TChild, One<TParent>?>> propertyOtherSide) where TParent : IEntity where TChild : IEntity
+    public static IManyToOne<TParent, TParentId, TChild, TChildId> InitManyToOne<TParent, TParentId, TChild, TChildId>(this TParent parent, Expression<Func<TParent, IMany<TChild, TChildId>>> propertyExpression, Expression<Func<TChild, One<TParent, TParentId>?>> propertyOtherSide)
+        where TParent : IEntity<TParentId>
+        where TParentId : IComparable<TParentId>, IEquatable<TParentId>
+        where TChild : IEntity<TChildId>
+        where TChildId : IComparable<TChildId>, IEquatable<TChildId>
     {
         var property = propertyExpression.GetPropertyInfo();
         var osProperty = propertyOtherSide.GetPropertyInfo();
 
-        return new ManyToOne<TParent, TChild>(parent, property, osProperty);
-
+        return new ManyToOne<TParent, TParentId, TChild, TChildId>(parent, property, osProperty);
     }
 }
\ No newline at end of file
diff --git a/MongoDB.Entities/Relationships/One.cs b/MongoDB.Entities/Relationships/One.cs
index 99f4aa7f2..3e9544e3b 100644
--- a/MongoDB.Entities/Relationships/One.cs
+++ b/MongoDB.Entities/Relationships/One.cs
@@ -11,7 +11,10 @@ namespace MongoDB.Entities
     /// Represents a one-to-one relationship with an IEntity.
     /// </summary>
     /// <typeparam name="T">Any type that implements IEntity</typeparam>
-    public class One<T> where T : IEntity
+    /// <typeparam name="TId">Any type that implements IEntity</typeparam>
+    public class One<T, TId>
+        where TId : IComparable<TId>, IEquatable<TId>
+        where T : IEntity<TId>
     {
         private T? _cache;
 
@@ -19,7 +22,7 @@ public class One<T> where T : IEntity
         /// The Id of the entity referenced by this instance.
         /// </summary>
         [AsObjectId]
-        public string? ID { get; set; }
+        public TId? ID { get; set; }
 
         public T? Cache
         {
@@ -28,9 +31,16 @@ public T? Cache
             {
                 value?.ThrowIfUnsaved();
                 _cache = value;
-                if (ID != value?.ID)
+                if (value is not null)
                 {
-                    ID = value?.ID!;
+                    if (!EqualityComparer<TId?>.Default.Equals(ID, value.ID))
+                    {
+                        ID = value.ID!;
+                    }
+                }
+                else
+                {
+                    ID = default;
                 }
             }
         }
@@ -52,18 +62,18 @@ internal One(T entity)
         /// Operator for returning a new One&lt;T&gt; object from a string ID
         /// </summary>
         /// <param name="id">The ID to create a new One&lt;T&gt; with</param>
-        public static implicit operator One<T>(string id)
+        public static implicit operator One<T, TId>(TId id)
         {
-            return new One<T>() { ID = id };
+            return new One<T, TId>() { ID = id };
         }
 
         /// <summary>
         /// Operator for returning a new One&lt;T&gt; object from an entity
         /// </summary>
         /// <param name="entity">The entity to make a reference to</param>
-        public static implicit operator One<T>(T entity)
+        public static implicit operator One<T, TId>(T entity)
         {
-            return new One<T>(entity);
+            return new One<T, TId>(entity);
         }
 
         /// <summary>
@@ -81,7 +91,7 @@ public static implicit operator One<T>(T entity)
                 return default;
             }
 
-            return Cache = await new Find<T>(context, collection ?? context.Collection<T>(collectionName)).OneAsync(ID, cancellation);
+            return Cache = await new Find<T, TId>(context, collection ?? context.Collection<T>(collectionName)).OneAsync(ID, cancellation);
         }
 
         /// <summary>
@@ -93,14 +103,14 @@ public static implicit operator One<T>(T entity)
         /// <param name="collectionName"></param>
         /// <param name="collection"></param>
         /// <returns>A Task containing the actual projected entity</returns>
-        public async Task<T?> ToEntityAsync<TFrom>(DBContext context, Expression<Func<TFrom, T>> projection, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<TFrom>? collection = null) where TFrom : IEntity
+        public async Task<TTo?> ToEntityAsync<TTo>(DBContext context, Expression<Func<T, TTo>> projection, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null)
         {
             if (ID is null)
             {
                 return default;
             }
 
-            return Cache = (await new Find<TFrom, T>(context, collection ?? context.Collection<TFrom>(collectionName))
+            return (await new Find<T, TId, TTo>(context, collection ?? context.Collection<T>(collectionName))
                         .Match(ID)
                         .Project(projection)
                         .ExecuteAsync(cancellation).ConfigureAwait(false))
@@ -116,17 +126,22 @@ public static implicit operator One<T>(T entity)
         /// <param name="collectionName"></param>
         /// <param name="collection"></param>
         /// <returns>A Task containing the actual projected entity</returns>
-        public async Task<T?> ToEntityAsync<TFrom>(DBContext context, Func<ProjectionDefinitionBuilder<TFrom>, ProjectionDefinition<TFrom, T>> projection, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<TFrom>? collection = null) where TFrom : IEntity
+        public async Task<TTo?> ToEntityAsync<TTo>(DBContext context, Func<ProjectionDefinitionBuilder<T>, ProjectionDefinition<T, TTo>> projection, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null)
         {
             if (ID is null)
             {
                 return default;
             }
-            return Cache = (await new Find<TFrom, T>(context, collection ?? context.Collection<TFrom>(collectionName))
+            return (await new Find<T, TId, TTo>(context, collection ?? context.Collection<T>(collectionName))
                         .Match(ID)
                         .Project(projection)
                         .ExecuteAsync(cancellation).ConfigureAwait(false))
                    .SingleOrDefault();
         }
     }
+
+    public class One<T> : One<T, string> where T : IEntity
+    {
+
+    }
 }

From 7f6a31250bb60aa45bedb06b41aaa3351bd6d991 Mon Sep 17 00:00:00 2001
From: Ahmed Fwela <ahmednfwela@bdaya-dev.com>
Date: Thu, 11 Nov 2021 23:19:51 +0200
Subject: [PATCH 22/26] WIP JoinRecord

---
 MongoDB.Entities/Core/IEntity.cs              | 18 -------
 .../Core/IgnoreManyPropsConvention.cs         |  3 +-
 MongoDB.Entities/Core/JoinRecordSerializer.cs | 27 ++++++++++
 MongoDB.Entities/DBContext/DBContext.cs       |  2 +-
 MongoDB.Entities/Relationships/JoinRecord.cs  | 50 +++++++++++++------
 5 files changed, 64 insertions(+), 36 deletions(-)
 create mode 100644 MongoDB.Entities/Core/JoinRecordSerializer.cs

diff --git a/MongoDB.Entities/Core/IEntity.cs b/MongoDB.Entities/Core/IEntity.cs
index cc9399b8d..f9beb1b1c 100644
--- a/MongoDB.Entities/Core/IEntity.cs
+++ b/MongoDB.Entities/Core/IEntity.cs
@@ -27,21 +27,3 @@ public interface IEntity<TId>
     /// </summary>
     TId GenerateNewID();
 }
-
-//public class MultipleIdEntity : IEntity<ValueTuple<Guid, ObjectId>>
-//{
-//    public (Guid, ObjectId) ID { get; set; }
-//    [BsonIgnore]
-//    public Guid Id1
-//    {
-//        get => ID.Item1;
-//        set => ID = (value, ID.Item2);
-//    }
-//    [BsonIgnore]
-//    public ObjectId Id2
-//    {
-//        get => ID.Item2;
-//        set => ID = (ID.Item1, value);
-//    }
-//    public (Guid, ObjectId) GenerateNewID() => (Guid.NewGuid(), ObjectId.GenerateNewId());
-//}
\ No newline at end of file
diff --git a/MongoDB.Entities/Core/IgnoreManyPropsConvention.cs b/MongoDB.Entities/Core/IgnoreManyPropsConvention.cs
index 859ab0c03..1fb0e1042 100644
--- a/MongoDB.Entities/Core/IgnoreManyPropsConvention.cs
+++ b/MongoDB.Entities/Core/IgnoreManyPropsConvention.cs
@@ -1,4 +1,5 @@
 using MongoDB.Bson.Serialization.Conventions;
+using MongoDB.Entities.NewMany;
 
 namespace MongoDB.Entities;
 
@@ -6,7 +7,7 @@ internal class IgnoreManyPropsConvention : ConventionBase, IMemberMapConvention
 {
     public void Apply(BsonMemberMap mMap)
     {
-        if (mMap.MemberType.Name == ManyBase.PropTypeName)
+        if (typeof(IMany<,>).IsAssignableFrom(mMap.MemberType))
         {
             _ = mMap.SetShouldSerializeMethod(_ => false);
         }
diff --git a/MongoDB.Entities/Core/JoinRecordSerializer.cs b/MongoDB.Entities/Core/JoinRecordSerializer.cs
new file mode 100644
index 000000000..1483929c8
--- /dev/null
+++ b/MongoDB.Entities/Core/JoinRecordSerializer.cs
@@ -0,0 +1,27 @@
+namespace MongoDB.Entities;
+
+internal class JoinRecordSerializer<T1, T2> : SerializerBase<JoinRecord<T1, T2>>, IBsonDocumentSerializer
+{
+    public override void Serialize(BsonSerializationContext context, BsonSerializationArgs args, JoinRecord<T1, T2> value)
+    {
+        //documents will exist in 2 formats
+
+    }
+    public override JoinRecord<T1, T2> Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args)
+    {
+
+    }
+
+    public bool TryGetMemberSerializationInfo(string memberName, out BsonSerializationInfo? serializationInfo)
+    {
+        switch (memberName)
+        {
+            case nameof(JoinRecord<T1, T2>.ID):
+                serializationInfo = null;
+                return false;
+            default:
+                serializationInfo = null;
+                return false;
+        }
+    }
+}
\ No newline at end of file
diff --git a/MongoDB.Entities/DBContext/DBContext.cs b/MongoDB.Entities/DBContext/DBContext.cs
index f7866a585..b7a4198e4 100644
--- a/MongoDB.Entities/DBContext/DBContext.cs
+++ b/MongoDB.Entities/DBContext/DBContext.cs
@@ -139,7 +139,7 @@ public static void InitStatic()
         BsonSerializer.RegisterSerializer(new FuzzyStringSerializer());
         BsonSerializer.RegisterSerializer(typeof(decimal), new DecimalSerializer(BsonType.Decimal128));
         BsonSerializer.RegisterSerializer(typeof(decimal?), new NullableSerializer<decimal>(new DecimalSerializer(BsonType.Decimal128)));
-
+        BsonSerializer.RegisterGenericSerializerDefinition(typeof(JoinRecord<,>), typeof(JoinRecordSerializer<,>));
         ConventionRegistry.Register(
             "DefaultConventions",
             new ConventionPack
diff --git a/MongoDB.Entities/Relationships/JoinRecord.cs b/MongoDB.Entities/Relationships/JoinRecord.cs
index 2f253f1a4..d11aa463d 100644
--- a/MongoDB.Entities/Relationships/JoinRecord.cs
+++ b/MongoDB.Entities/Relationships/JoinRecord.cs
@@ -1,30 +1,48 @@
-using MongoDB.Bson.Serialization.Attributes;
-using System;
+namespace MongoDB.Entities;
 
-namespace MongoDB.Entities;
 
 /// <summary>
 /// Represents a parent-child relationship between two entities.
 /// <para>TIP: The ParentID and ChildID switches around for many-to-many relationships depending on the side of the relationship you're accessing.</para>
 /// </summary>
-public class JoinRecord<TId1, TId2> : Entity<(TId1 ParentID, TId2 ChildID)>
+public class JoinRecord : Entity
 {
-    ///// <summary>
-    ///// The ID of the parent IEntity for both one-to-many and the owner side of many-to-many relationships.
-    ///// </summary>
-    //[BsonIgnore]
-    //public string ParentID { get; set; } = null!;
+    /// <summary>
+    /// The ID of the parent IEntity for both one-to-many and the owner side of many-to-many relationships.
+    /// </summary>    
+    public string ParentID { get; set; } = null!;
 
-    ///// <summary>
-    ///// The ID of the child IEntity in one-to-many relationships and the ID of the inverse side IEntity in many-to-many relationships.
-    ///// </summary>
-    //[AsObjectId]
-    //public string ChildID { get; set; } = null!;
+    /// <summary>
+    /// The ID of the child IEntity in one-to-many relationships and the ID of the inverse side IEntity in many-to-many relationships.
+    /// </summary>    
+    public string ChildID { get; set; } = null!;
+}
+
+/// <summary>
+/// Represents a parent-child relationship between two entities.
+/// <para>TIP: The ParentID and ChildID switches around for many-to-many relationships depending on the side of the relationship you're accessing.</para>
+/// </summary>
+public class JoinRecord<TParentId, TChildId> : Entity<(TParentId ParentId, TChildId ChildId)>
+{
+    public JoinRecord(TParentId parentID, TChildId childID)
+    {
+        ID = (parentID, childID);
+    }
+
+    /// <summary>
+    /// The ID of the parent IEntity for both one-to-many and the owner side of many-to-many relationships.
+    /// </summary>    
+    [BsonIgnore]
+    public TParentId ParentID => ID.ParentId;
 
+    /// <summary>
+    /// The ID of the child IEntity in one-to-many relationships and the ID of the inverse side IEntity in many-to-many relationships.
+    /// </summary>    
+    [BsonIgnore]
+    public TChildId ChildID => ID.ChildId;
 
-    public override (TId1 ParentID, TId2 ChildID) GenerateNewID()
+    public override (TParentId ParentId, TChildId ChildId) GenerateNewID()
     {
-        //the caller is responsible for assigning ids
         throw new NotImplementedException();
     }
 }

From 84d9bbfb4df25f2538d4b0ff6f0a846e914498c5 Mon Sep 17 00:00:00 2001
From: Ahmed Fwela <ahmednfwela@bdaya-dev.com>
Date: Tue, 7 Dec 2021 10:26:14 +0200
Subject: [PATCH 23/26] WIP attempt to remove dependency on IEntity

---
 MongoDB.Entities/Builders/Distinct.Base.cs    |  52 ++++
 .../Builders/Distinct.Interface.cs            |  25 ++
 MongoDB.Entities/Builders/Distinct.cs         |  60 +---
 .../Builders/FilterQuery.Extensions.cs        |  41 +++
 .../Builders/FilterQuery.Interface.cs         |  78 ++++++
 MongoDB.Entities/Builders/FilterQuery.cs      | 104 +++++++
 MongoDB.Entities/Builders/FilterQueryBase.cs  | 167 -----------
 MongoDB.Entities/Builders/Find.Base.cs        | 114 ++++++++
 MongoDB.Entities/Builders/Find.Interface.cs   |  68 +++++
 MongoDB.Entities/Builders/Find.cs             | 219 +++------------
 .../Builders/ICollectionRelated.cs            |   1 +
 MongoDB.Entities/Builders/Index.Interface.cs  |  22 ++
 MongoDB.Entities/Builders/Index.cs            |  32 +--
 MongoDB.Entities/Builders/PagedSearch.cs      |  28 +-
 MongoDB.Entities/Builders/Replace.cs          |   2 +-
 .../Builders/SortFilterQueryBase.Interface.cs |  20 ++
 .../Builders/SortFilterQueryBase.cs           |  14 +-
 MongoDB.Entities/Core/EntityCache.cs          |  10 +-
 MongoDB.Entities/Core/Prop.cs                 |  16 +-
 MongoDB.Entities/DBContext/DBContext.Find.cs  |  16 +-
 MongoDB.Entities/Extensions/Entity.cs         |   8 +-
 MongoDB.Entities/GlobalUsing.cs               |   2 +
 MongoDB.Entities/MongoDB.Entities.csproj      |   2 +-
 MongoDB.Entities/Relationships/NewMany.cs     |  75 ++---
 MongoDB.Entities/Relationships/One.cs         | 262 ++++++++++--------
 Tests/TestModifiedBy.cs                       |   2 +-
 26 files changed, 800 insertions(+), 640 deletions(-)
 create mode 100644 MongoDB.Entities/Builders/Distinct.Base.cs
 create mode 100644 MongoDB.Entities/Builders/Distinct.Interface.cs
 create mode 100644 MongoDB.Entities/Builders/FilterQuery.Extensions.cs
 create mode 100644 MongoDB.Entities/Builders/FilterQuery.Interface.cs
 create mode 100644 MongoDB.Entities/Builders/FilterQuery.cs
 delete mode 100644 MongoDB.Entities/Builders/FilterQueryBase.cs
 create mode 100644 MongoDB.Entities/Builders/Find.Base.cs
 create mode 100644 MongoDB.Entities/Builders/Find.Interface.cs
 create mode 100644 MongoDB.Entities/Builders/Index.Interface.cs
 create mode 100644 MongoDB.Entities/Builders/SortFilterQueryBase.Interface.cs

diff --git a/MongoDB.Entities/Builders/Distinct.Base.cs b/MongoDB.Entities/Builders/Distinct.Base.cs
new file mode 100644
index 000000000..4b791d1a2
--- /dev/null
+++ b/MongoDB.Entities/Builders/Distinct.Base.cs
@@ -0,0 +1,52 @@
+namespace MongoDB.Entities;
+
+public class DistinctBase<T, TProperty, TSelf> : FilterQueryBase<T, TSelf>, IDistinct<T,TProperty,TSelf>
+    where TSelf : DistinctBase<T, TProperty, TSelf>
+{
+    internal DistinctOptions _options = new();
+    internal FieldDefinition<T, TProperty>? _field;
+
+    internal DistinctBase(DistinctBase<T, TProperty, TSelf> other) : base(other)
+    {
+        _options = other._options;
+        _field = other._field;
+    }
+    internal DistinctBase(Dictionary<Type, (object filterDef, bool prepend)> globalFilters) : base(globalFilters)
+    {
+        _globalFilters = globalFilters;
+    }
+
+
+    private TSelf This => (TSelf)this;
+
+
+    /// <summary>
+    /// Specify an option for this find command (use multiple times if needed)
+    /// </summary>
+    /// <param name="option">x => x.OptionName = OptionValue</param>
+    public TSelf Option(Action<DistinctOptions> option)
+    {
+        option(_options);
+        return This;
+    }
+
+    /// <summary>
+    /// Specify the property you want to get the unique values for (as a string path)
+    /// </summary>
+    /// <param name="property">ex: "Address.Street"</param>
+    public TSelf Property(string property)
+    {
+        _field = property;
+        return This;
+    }
+
+    /// <summary>
+    /// Specify the property you want to get the unique values for (as a member expression)
+    /// </summary>
+    /// <param name="property">x => x.Address.Street</param>
+    public TSelf Property(Expression<Func<T, TProperty>> property)
+    {
+        _field = property.FullPath();
+        return This;
+    }
+}
diff --git a/MongoDB.Entities/Builders/Distinct.Interface.cs b/MongoDB.Entities/Builders/Distinct.Interface.cs
new file mode 100644
index 000000000..a766d6789
--- /dev/null
+++ b/MongoDB.Entities/Builders/Distinct.Interface.cs
@@ -0,0 +1,25 @@
+namespace MongoDB.Entities;
+
+public interface IDistinct<T, TProperty, TSelf>
+    where TSelf : IDistinct<T, TProperty, TSelf>
+{
+    /// <summary>
+    /// Specify an option for this find command (use multiple times if needed)
+    /// </summary>
+    /// <param name="option">x => x.OptionName = OptionValue</param>
+    public TSelf Option(Action<DistinctOptions> option);
+
+    /// <summary>
+    /// Specify the property you want to get the unique values for (as a string path)
+    /// </summary>
+    /// <param name="property">ex: "Address.Street"</param>
+    public TSelf Property(string property);
+
+    /// <summary>
+    /// Specify the property you want to get the unique values for (as a member expression)
+    /// </summary>
+    /// <param name="property">x => x.Address.Street</param>
+    public TSelf Property(Expression<Func<T, TProperty>> property);
+
+
+}
diff --git a/MongoDB.Entities/Builders/Distinct.cs b/MongoDB.Entities/Builders/Distinct.cs
index f2bffb03f..1b6e59604 100644
--- a/MongoDB.Entities/Builders/Distinct.cs
+++ b/MongoDB.Entities/Builders/Distinct.cs
@@ -1,67 +1,11 @@
 namespace MongoDB.Entities;
 
-public class DistinctBase<T, TId, TProperty, TSelf> : FilterQueryBase<T, TId, TSelf>
-    where TId : IComparable<TId>, IEquatable<TId>
-    where T : IEntity<TId>
-    where TSelf : DistinctBase<T, TId, TProperty, TSelf>
-{
-    internal DistinctOptions _options = new();
-    internal FieldDefinition<T, TProperty>? _field;
-
-    internal DistinctBase(DistinctBase<T, TId, TProperty, TSelf> other) : base(other)
-    {
-        _options = other._options;
-        _field = other._field;
-    }
-    internal DistinctBase(Dictionary<Type, (object filterDef, bool prepend)> globalFilters) : base(globalFilters)
-    {
-        _globalFilters = globalFilters;
-    }
-
-
-    private TSelf This => (TSelf)this;
-
-
-    /// <summary>
-    /// Specify an option for this find command (use multiple times if needed)
-    /// </summary>
-    /// <param name="option">x => x.OptionName = OptionValue</param>
-    public TSelf Option(Action<DistinctOptions> option)
-    {
-        option(_options);
-        return This;
-    }
-
-    /// <summary>
-    /// Specify the property you want to get the unique values for (as a string path)
-    /// </summary>
-    /// <param name="property">ex: "Address.Street"</param>
-    public TSelf Property(string property)
-    {
-        _field = property;
-        return This;
-    }
-
-    /// <summary>
-    /// Specify the property you want to get the unique values for (as a member expression)
-    /// </summary>
-    /// <param name="property">x => x.Address.Street</param>
-    public TSelf Property(Expression<Func<T, object>> property)
-    {
-        _field = property.FullPath();
-        return This;
-    }
-}
-
 /// <summary>
 /// Represents a MongoDB Distinct command where you can get back distinct values for a given property of a given Entity.
 /// </summary>
 /// <typeparam name="T">Any Entity that implements IEntity interface</typeparam>
 /// <typeparam name="TProperty">The type of the property of the entity you'd like to get unique values for</typeparam>
-/// <typeparam name="TId">The type of the id</typeparam>
-public class Distinct<T, TId, TProperty> : DistinctBase<T, TId, TProperty, Distinct<T, TId, TProperty>>, ICollectionRelated<T>
-     where TId : IComparable<TId>, IEquatable<TId>
-    where T : IEntity<TId>
+public class Distinct<T, TProperty> : DistinctBase<T, TProperty, Distinct<T, TProperty>>, ICollectionRelated<T>
 {
     public DBContext Context { get; }
     public IMongoCollection<T> Collection { get; }
@@ -69,7 +13,7 @@ public class Distinct<T, TId, TProperty> : DistinctBase<T, TId, TProperty, Disti
     internal Distinct(
         DBContext context,
         IMongoCollection<T> collection,
-        DistinctBase<T, TId, TProperty, Distinct<T, TId, TProperty>> other) : base(other)
+        DistinctBase<T, TProperty, Distinct<T, TProperty>> other) : base(other)
     {
         Context = context;
         Collection = collection;
diff --git a/MongoDB.Entities/Builders/FilterQuery.Extensions.cs b/MongoDB.Entities/Builders/FilterQuery.Extensions.cs
new file mode 100644
index 000000000..b2be6b40b
--- /dev/null
+++ b/MongoDB.Entities/Builders/FilterQuery.Extensions.cs
@@ -0,0 +1,41 @@
+namespace MongoDB.Entities;
+
+public static class FilterExt
+{
+    //protected FilterDefinition<T> MergedFilter => Logic.MergeWithGlobalFilter(_ignoreGlobalFilters, _globalFilters, _filter);
+    /// <summary>
+    /// Specify an IEntity ID as the matching criteria
+    /// </summary>
+    /// <param name="self">the query</param>
+    internal static FilterDefinition<TEntity> MergedFilter<TEntity, TSelf>(this TSelf self)
+        where TSelf : IFilterBuilder<TEntity, TSelf>
+    {
+        return Logic.MergeWithGlobalFilter(self.IsIgnoreGlobalFilters, self.GlobalFilters, self.Filter);
+    }
+
+    /// <summary>
+    /// Specify an IEntity ID as the matching criteria
+    /// </summary>
+    /// <param name="self">the query</param>
+    /// <param name="id">A unique IEntity ID</param>
+    public static TSelf MatchID<TEntity, TId, TSelf>(this TSelf self, TId id)
+        where TId : IComparable<TId>, IEquatable<TId>
+        where TEntity : IEntity<TId>
+        where TSelf : IFilterBuilder<TEntity, TSelf>
+    {
+        return self.Match(f => f.Eq(t => t.ID, id));
+    }
+
+    /// <summary>
+    /// Specify an IEntity ID as the matching criteria
+    /// </summary>
+    /// <param name="self">the query</param>
+    /// <param name="id">A unique IEntity ID</param>
+    public static TSelf Match<TEntity, TId, TSelf>(this TSelf self, TId id)
+        where TId : IComparable<TId>, IEquatable<TId>
+        where TEntity : IEntity<TId>
+        where TSelf : IFilterBuilder<TEntity, TSelf>
+    {
+        return self.MatchID<TEntity, TId, TSelf>(id);
+    }
+}
\ No newline at end of file
diff --git a/MongoDB.Entities/Builders/FilterQuery.Interface.cs b/MongoDB.Entities/Builders/FilterQuery.Interface.cs
new file mode 100644
index 000000000..ed628ad29
--- /dev/null
+++ b/MongoDB.Entities/Builders/FilterQuery.Interface.cs
@@ -0,0 +1,78 @@
+namespace MongoDB.Entities;
+
+public interface IFilterBuilder<T, TSelf>
+    where TSelf : IFilterBuilder<T, TSelf>
+{
+    internal bool IsIgnoreGlobalFilters { get; }
+    internal FilterDefinition<T> Filter { get; }
+    internal Dictionary<Type, (object filterDef, bool prepend)> GlobalFilters { get; }
+
+    /// <summary>
+    /// Specify that this operation should ignore any global filters
+    /// </summary>
+    TSelf IgnoreGlobalFilters(bool IgnoreGlobalFilters = true);
+
+    /// <summary>
+    /// Specify the matching criteria with a lambda expression
+    /// </summary>
+    /// <param name="expression">x => x.Property == Value</param>
+    TSelf Match(Expression<Func<T, bool>> expression);
+
+    /// <summary>
+    /// Specify the matching criteria with a filter expression
+    /// </summary>
+    /// <param name="filter">f => f.Eq(x => x.Prop, Value) &amp; f.Gt(x => x.Prop, Value)</param>
+    TSelf Match(Func<FilterDefinitionBuilder<T>, FilterDefinition<T>> filter);
+
+    /// <summary>
+    /// Specify the matching criteria with a filter definition
+    /// </summary>
+    /// <param name="filterDefinition">A filter definition</param>
+    TSelf Match(FilterDefinition<T> filterDefinition);
+
+    /// <summary>
+    /// Specify the matching criteria with a template
+    /// </summary>
+    /// <param name="template">A Template with a find query</param>
+    TSelf Match(Template template);
+
+    /// <summary>
+    /// Specify a search term to find results from the text index of this particular collection.
+    /// <para>TIP: Make sure to define a text index with DB.Index&lt;T&gt;() before searching</para>
+    /// </summary>
+    /// <param name="searchType">The type of text matching to do</param>
+    /// <param name="searchTerm">The search term</param>
+    /// <param name="caseSensitive">Case sensitivity of the search (optional)</param>
+    /// <param name="diacriticSensitive">Diacritic sensitivity of the search (optional)</param>
+    /// <param name="language">The language for the search (optional)</param>
+    TSelf Match(Search searchType, string searchTerm, bool caseSensitive = false, bool diacriticSensitive = false, string? language = null);
+
+    /// <summary>
+    /// Specify criteria for matching entities based on GeoSpatial data (longitude &amp; latitude)
+    /// <para>TIP: Make sure to define a Geo2DSphere index with DB.Index&lt;T&gt;() before searching</para>
+    /// <para>Note: DB.FluentGeoNear() supports more advanced options</para>
+    /// </summary>
+    /// <param name="coordinatesProperty">The property where 2DCoordinates are stored</param>
+    /// <param name="nearCoordinates">The search point</param>
+    /// <param name="maxDistance">Maximum distance in meters from the search point</param>
+    /// <param name="minDistance">Minimum distance in meters from the search point</param>
+    TSelf Match(Expression<Func<T, object>> coordinatesProperty, Coordinates2D nearCoordinates, double? maxDistance = null, double? minDistance = null);
+
+    /// <summary>
+    /// Specify the matching criteria with an aggregation expression (i.e. $expr)
+    /// </summary>
+    /// <param name="expression">{ $gt: ['$Property1', '$Property2'] }</param>
+    TSelf MatchExpression(string expression);
+
+    /// <summary>
+    /// Specify the matching criteria with a Template
+    /// </summary>
+    /// <param name="template">A Template object</param>
+    TSelf MatchExpression(Template template);
+
+    /// <summary>
+    /// Specify the matching criteria with a JSON string
+    /// </summary>
+    /// <param name="jsonString">{ Title : 'The Power Of Now' }</param>
+    TSelf MatchString(string jsonString);
+}
diff --git a/MongoDB.Entities/Builders/FilterQuery.cs b/MongoDB.Entities/Builders/FilterQuery.cs
new file mode 100644
index 000000000..e99552848
--- /dev/null
+++ b/MongoDB.Entities/Builders/FilterQuery.cs
@@ -0,0 +1,104 @@
+namespace MongoDB.Entities;
+
+
+public abstract class FilterQueryBase<T, TSelf> : IFilterBuilder<T, TSelf>
+    where TSelf : FilterQueryBase<T, TSelf>
+
+{
+    internal FilterDefinition<T> _filter = Builders<T>.Filter.Empty;
+    internal Dictionary<Type, (object filterDef, bool prepend)> _globalFilters;
+    internal bool _ignoreGlobalFilters;
+
+    internal FilterQueryBase(IFilterBuilder<T, TSelf> other) : this(globalFilters: other.GlobalFilters)
+    {
+        _filter = other.Filter;
+        _ignoreGlobalFilters = other.IsIgnoreGlobalFilters;
+    }
+
+    internal FilterQueryBase(Dictionary<Type, (object filterDef, bool prepend)> globalFilters)
+    {
+        _globalFilters = globalFilters;
+    }
+
+    bool IFilterBuilder<T, TSelf>.IsIgnoreGlobalFilters => _ignoreGlobalFilters;
+    FilterDefinition<T> IFilterBuilder<T, TSelf>.Filter => _filter;
+    Dictionary<Type, (object filterDef, bool prepend)> IFilterBuilder<T, TSelf>.GlobalFilters => _globalFilters;
+
+    private TSelf This => (TSelf)this;
+
+    /// <summary>
+    /// Specify that this operation should ignore any global filters
+    /// </summary>
+    public TSelf IgnoreGlobalFilters(bool IgnoreGlobalFilters = true)
+    {
+        _ignoreGlobalFilters = IgnoreGlobalFilters;
+        return This;
+    }
+
+    public TSelf Match(Expression<Func<T, bool>> expression)
+    {
+        return Match(f => f.Where(expression));
+    }
+
+    public TSelf Match(Func<FilterDefinitionBuilder<T>, FilterDefinition<T>> filter)
+    {
+        _filter &= filter(Builders<T>.Filter);
+        return This;
+    }
+
+    public TSelf Match(FilterDefinition<T> filterDefinition)
+    {
+        _filter &= filterDefinition;
+        return This;
+    }
+
+    public TSelf Match(Template template)
+    {
+        _filter &= template.RenderToString();
+        return This;
+    }
+
+    public TSelf Match(Search searchType, string searchTerm, bool caseSensitive = false, bool diacriticSensitive = false, string? language = null)
+    {
+        if (searchType == Search.Fuzzy)
+        {
+            searchTerm = searchTerm.ToDoubleMetaphoneHash();
+            caseSensitive = false;
+            diacriticSensitive = false;
+            language = null;
+        }
+
+        return Match(
+            f => f.Text(
+                searchTerm,
+                new TextSearchOptions
+                {
+                    CaseSensitive = caseSensitive,
+                    DiacriticSensitive = diacriticSensitive,
+                    Language = language
+                }));
+    }
+
+    public TSelf Match(Expression<Func<T, object>> coordinatesProperty, Coordinates2D nearCoordinates, double? maxDistance = null, double? minDistance = null)
+    {
+        return Match(f => f.Near(coordinatesProperty, nearCoordinates.ToGeoJsonPoint(), maxDistance, minDistance));
+    }
+
+    public TSelf MatchExpression(string expression)
+    {
+        _filter &= "{$expr:" + expression + "}";
+        return This;
+    }
+
+    public TSelf MatchExpression(Template template)
+    {
+        return MatchExpression(template.RenderToString());
+    }
+
+
+    public TSelf MatchString(string jsonString)
+    {
+        _filter &= jsonString;
+        return This;
+    }
+}
diff --git a/MongoDB.Entities/Builders/FilterQueryBase.cs b/MongoDB.Entities/Builders/FilterQueryBase.cs
deleted file mode 100644
index eaa32de9a..000000000
--- a/MongoDB.Entities/Builders/FilterQueryBase.cs
+++ /dev/null
@@ -1,167 +0,0 @@
-namespace MongoDB.Entities;
-
-public abstract class FilterQueryBase<T, TId, TSelf>
-    where TId : IComparable<TId>, IEquatable<TId>
-    where T : IEntity<TId>
-    where TSelf : FilterQueryBase<T, TId, TSelf>
-
-{
-    internal FilterDefinition<T> _filter = Builders<T>.Filter.Empty;
-    internal Dictionary<Type, (object filterDef, bool prepend)> _globalFilters;
-    internal bool _ignoreGlobalFilters;
-
-    internal FilterQueryBase(FilterQueryBase<T, TId, TSelf> other) : this(globalFilters: other._globalFilters)
-    {
-        _filter = other._filter;
-        _ignoreGlobalFilters = other._ignoreGlobalFilters;
-    }
-    internal FilterQueryBase(Dictionary<Type, (object filterDef, bool prepend)> globalFilters)
-    {
-        _globalFilters = globalFilters;
-    }
-
-    protected FilterDefinition<T> MergedFilter => Logic.MergeWithGlobalFilter(_ignoreGlobalFilters, _globalFilters, _filter);
-    private TSelf This => (TSelf)this;
-
-
-    /// <summary>
-    /// Specify that this operation should ignore any global filters
-    /// </summary>
-    public TSelf IgnoreGlobalFilters()
-    {
-        _ignoreGlobalFilters = true;
-        return This;
-    }
-
-
-
-    /// <summary>
-    /// Specify an IEntity ID as the matching criteria
-    /// </summary>
-    /// <param name="ID">A unique IEntity ID</param>
-    public TSelf Match(TId ID)
-    {
-        return Match(f => f.Eq(t => t.ID, ID));
-    }
-
-    /// <summary>
-    /// Specify the matching criteria with a lambda expression
-    /// </summary>
-    /// <param name="expression">x => x.Property == Value</param>
-    public TSelf Match(Expression<Func<T, bool>> expression)
-    {
-        return Match(f => f.Where(expression));
-    }
-
-    /// <summary>
-    /// Specify the matching criteria with a filter expression
-    /// </summary>
-    /// <param name="filter">f => f.Eq(x => x.Prop, Value) &amp; f.Gt(x => x.Prop, Value)</param>
-    public TSelf Match(Func<FilterDefinitionBuilder<T>, FilterDefinition<T>> filter)
-    {
-        _filter &= filter(Builders<T>.Filter);
-        return This;
-    }
-
-    /// <summary>
-    /// Specify the matching criteria with a filter definition
-    /// </summary>
-    /// <param name="filterDefinition">A filter definition</param>
-    public TSelf Match(FilterDefinition<T> filterDefinition)
-    {
-        _filter &= filterDefinition;
-        return This;
-    }
-
-    /// <summary>
-    /// Specify the matching criteria with a template
-    /// </summary>
-    /// <param name="template">A Template with a find query</param>
-    public TSelf Match(Template template)
-    {
-        _filter &= template.RenderToString();
-        return This;
-    }
-
-    /// <summary>
-    /// Specify a search term to find results from the text index of this particular collection.
-    /// <para>TIP: Make sure to define a text index with DB.Index&lt;T&gt;() before searching</para>
-    /// </summary>
-    /// <param name="searchType">The type of text matching to do</param>
-    /// <param name="searchTerm">The search term</param>
-    /// <param name="caseSensitive">Case sensitivity of the search (optional)</param>
-    /// <param name="diacriticSensitive">Diacritic sensitivity of the search (optional)</param>
-    /// <param name="language">The language for the search (optional)</param>
-    public TSelf Match(Search searchType, string searchTerm, bool caseSensitive = false, bool diacriticSensitive = false, string? language = null)
-    {
-        if (searchType == Search.Fuzzy)
-        {
-            searchTerm = searchTerm.ToDoubleMetaphoneHash();
-            caseSensitive = false;
-            diacriticSensitive = false;
-            language = null;
-        }
-
-        return Match(
-            f => f.Text(
-                searchTerm,
-                new TextSearchOptions
-                {
-                    CaseSensitive = caseSensitive,
-                    DiacriticSensitive = diacriticSensitive,
-                    Language = language
-                }));
-    }
-
-    /// <summary>
-    /// Specify criteria for matching entities based on GeoSpatial data (longitude &amp; latitude)
-    /// <para>TIP: Make sure to define a Geo2DSphere index with DB.Index&lt;T&gt;() before searching</para>
-    /// <para>Note: DB.FluentGeoNear() supports more advanced options</para>
-    /// </summary>
-    /// <param name="coordinatesProperty">The property where 2DCoordinates are stored</param>
-    /// <param name="nearCoordinates">The search point</param>
-    /// <param name="maxDistance">Maximum distance in meters from the search point</param>
-    /// <param name="minDistance">Minimum distance in meters from the search point</param>
-    public TSelf Match(Expression<Func<T, object>> coordinatesProperty, Coordinates2D nearCoordinates, double? maxDistance = null, double? minDistance = null)
-    {
-        return Match(f => f.Near(coordinatesProperty, nearCoordinates.ToGeoJsonPoint(), maxDistance, minDistance));
-    }
-
-    /// <summary>
-    /// Specify the matching criteria with an aggregation expression (i.e. $expr)
-    /// </summary>
-    /// <param name="expression">{ $gt: ['$Property1', '$Property2'] }</param>
-    public TSelf MatchExpression(string expression)
-    {
-        _filter &= "{$expr:" + expression + "}";
-        return This;
-    }
-
-    /// <summary>
-    /// Specify the matching criteria with a Template
-    /// </summary>
-    /// <param name="template">A Template object</param>
-    public TSelf MatchExpression(Template template)
-    {
-        return MatchExpression(template.RenderToString());
-    }
-
-    /// <summary>
-    /// Specify an IEntity ID as the matching criteria
-    /// </summary>
-    /// <param name="ID">A unique IEntity ID</param>
-    public TSelf MatchID(TId ID)
-    {
-        return Match(f => f.Eq(t => t.ID, ID));
-    }
-
-    /// <summary>
-    /// Specify the matching criteria with a JSON string
-    /// </summary>
-    /// <param name="jsonString">{ Title : 'The Power Of Now' }</param>
-    public TSelf MatchString(string jsonString)
-    {
-        _filter &= jsonString;
-        return This;
-    }
-}
diff --git a/MongoDB.Entities/Builders/Find.Base.cs b/MongoDB.Entities/Builders/Find.Base.cs
new file mode 100644
index 000000000..703a38675
--- /dev/null
+++ b/MongoDB.Entities/Builders/Find.Base.cs
@@ -0,0 +1,114 @@
+namespace MongoDB.Entities;
+
+public abstract class FindBase<T, TProjection, TSelf> :
+    SortFilterQueryBase<T, TSelf>, IFindBuilder<T, TProjection, TSelf>
+    where TSelf : FindBase<T, TProjection, TSelf>
+{
+    internal FindOptions<T, TProjection> _options = new();
+
+    internal FindBase(FindBase<T, TProjection, TSelf> other) : base(other)
+    {
+        _options = other._options;
+    }
+    internal FindBase(Dictionary<Type, (object filterDef, bool prepend)> globalFilters) : base(globalFilters: globalFilters)
+    {
+        _globalFilters = globalFilters;
+    }
+    public abstract DBContext Context { get; }
+    private TSelf This => (TSelf)this;
+
+
+    public TSelf Skip(int skipCount)
+    {
+        _options.Skip = skipCount;
+        return This;
+    }
+
+
+    public TSelf Limit(int takeCount)
+    {
+        _options.Limit = takeCount;
+        return This;
+    }
+
+
+    public TSelf Project(Expression<Func<T, TProjection>> expression)
+    {
+        return Project(p => p.Expression(expression));
+    }
+
+    public TSelf Project(Func<ProjectionDefinitionBuilder<T>, ProjectionDefinition<T, TProjection>> projection)
+    {
+        _options.Projection = projection(Builders<T>.Projection);
+        return This;
+    }
+
+
+    public TSelf IncludeRequiredProps()
+    {
+        if (typeof(T) != typeof(TProjection))
+            throw new InvalidOperationException("IncludeRequiredProps() cannot be used when projecting to a different type.");
+
+        _options.Projection = Context.Cache<T>().CombineWithRequiredProps(_options.Projection);
+        return This;
+    }
+
+
+    public TSelf ProjectExcluding(Expression<Func<T, object>> exclusion)
+    {
+        var props = (exclusion.Body as NewExpression)?.Arguments
+            .Select(a => a.ToString().Split('.')[1]);
+
+        if (props == null || !props.Any())
+            throw new ArgumentException("Unable to get any properties from the exclusion expression!");
+
+        var defs = new List<ProjectionDefinition<T>>(props.Count());
+
+        foreach (var prop in props)
+        {
+            defs.Add(Builders<T>.Projection.Exclude(prop));
+        }
+
+        _options.Projection = Builders<T>.Projection.Combine(defs);
+
+        return This;
+    }
+
+
+    public TSelf Option(Action<FindOptions<T, TProjection>> option)
+    {
+        option(_options);
+        return This;
+    }
+
+    private void AddTxtScoreToProjection(string propName)
+    {
+        if (_options.Projection == null) _options.Projection = "{}";
+
+        _options.Projection =
+            _options.Projection
+            .Render(BsonSerializer.SerializerRegistry.GetSerializer<T>(), BsonSerializer.SerializerRegistry)
+            .Document.Add(propName, new BsonDocument { { "$meta", "textScore" } });
+    }
+
+
+    public TSelf SortByTextScore()
+    {
+        return SortByTextScore<object?>(null);
+    }
+
+
+    public TSelf SortByTextScore<TProp>(Expression<Func<T, TProp>>? scoreProperty)
+    {
+        switch (scoreProperty)
+        {
+            case null:
+                AddTxtScoreToProjection("_Text_Match_Score_");
+                return Sort(s => s.MetaTextScore("_Text_Match_Score_"));
+
+            default:
+                AddTxtScoreToProjection(Prop.Path(scoreProperty));
+                return Sort(s => s.MetaTextScore(Prop.Path(scoreProperty)));
+        }
+    }
+}
diff --git a/MongoDB.Entities/Builders/Find.Interface.cs b/MongoDB.Entities/Builders/Find.Interface.cs
new file mode 100644
index 000000000..72996d442
--- /dev/null
+++ b/MongoDB.Entities/Builders/Find.Interface.cs
@@ -0,0 +1,68 @@
+
+namespace MongoDB.Entities
+{
+    public interface IProjectionBuilder<T, TProjection, TSelf>
+    {
+        ///// <summary>
+        ///// Specify to automatically include all properties marked with [BsonRequired] attribute on the entity in the final projection.
+        ///// <para>HINT: this method should only be called after the .Project() method.</para>
+        ///// </summary>
+        //TSelf IncludeRequiredProps();
+
+        /// <summary>
+        /// Specify how to project the results using a lambda expression
+        /// </summary>
+        /// <param name="expression">x => new Test { PropName = x.Prop }</param>
+        TSelf Project(Expression<Func<T, TProjection>> expression);
+
+        /// <summary>
+        /// Specify how to project the results using a projection expression
+        /// </summary>
+        /// <param name="projection">p => p.Include("Prop1").Exclude("Prop2")</param>
+        TSelf Project(Func<ProjectionDefinitionBuilder<T>, ProjectionDefinition<T, TProjection>> projection);
+
+        /// <summary>
+        /// Specify how to project the results using an exclusion projection expression.
+        /// </summary>
+        /// <param name="exclusion">x => new { x.PropToExclude, x.AnotherPropToExclude }</param>
+        TSelf ProjectExcluding(Expression<Func<T, object>> exclusion);
+
+
+    }
+    public interface IFindBuilder<T, TProjection, TSelf>
+        where TSelf : IFindBuilder<T, TProjection, TSelf>
+    {
+
+
+        /// <summary>
+        /// Specify how many entities to Take/Limit
+        /// </summary>
+        /// <param name="takeCount">The number to limit/take</param>
+        TSelf Limit(int takeCount);
+
+        /// <summary>
+        /// Specify an option for this find command (use multiple times if needed)
+        /// </summary>
+        /// <param name="option">x => x.OptionName = OptionValue</param>
+        TSelf Option(Action<FindOptions<T, TProjection>> option);
+
+        /// <summary>
+        /// Specify how many entities to skip
+        /// </summary>
+        /// <param name="skipCount">The number to skip</param>
+        TSelf Skip(int skipCount);
+
+        /// <summary>
+        /// Sort the results of a text search by the MetaTextScore
+        /// <para>TIP: Use this method after .Project() if you need to do a projection also</para>
+        /// </summary>
+        TSelf SortByTextScore();
+
+        /// <summary>
+        /// Sort the results of a text search by the MetaTextScore and get back the score as well
+        /// <para>TIP: Use this method after .Project() if you need to do a projection also</para>
+        /// </summary>
+        /// <param name="scoreProperty">x => x.TextScoreProp</param>
+        TSelf SortByTextScore<TProp>(Expression<Func<T, TProp>>? scoreProperty);
+    }
+}
\ No newline at end of file
diff --git a/MongoDB.Entities/Builders/Find.cs b/MongoDB.Entities/Builders/Find.cs
index f77d73f67..261ee0ccc 100644
--- a/MongoDB.Entities/Builders/Find.cs
+++ b/MongoDB.Entities/Builders/Find.cs
@@ -1,163 +1,17 @@
 namespace MongoDB.Entities;
 
-public abstract class FindBase<T, TId, TProjection, TSelf> : SortFilterQueryBase<T, TId, TSelf>
-    where TId : IComparable<TId>, IEquatable<TId>
-    where T : IEntity<TId>
-    where TSelf : FindBase<T, TId, TProjection, TSelf>
-{
-    internal FindOptions<T, TProjection> _options = new();
-
-    internal FindBase(FindBase<T, TId, TProjection, TSelf> other) : base(other)
-    {
-        _options = other._options;
-    }
-    internal FindBase(Dictionary<Type, (object filterDef, bool prepend)> globalFilters) : base(globalFilters: globalFilters)
-    {
-        _globalFilters = globalFilters;
-    }
-    public abstract DBContext Context { get; }
-    private TSelf This => (TSelf)this;
-
-    /// <summary>
-    /// Specify how many entities to skip
-    /// </summary>
-    /// <param name="skipCount">The number to skip</param>
-    public TSelf Skip(int skipCount)
-    {
-        _options.Skip = skipCount;
-        return This;
-    }
-
-    /// <summary>
-    /// Specify how many entities to Take/Limit
-    /// </summary>
-    /// <param name="takeCount">The number to limit/take</param>
-    public TSelf Limit(int takeCount)
-    {
-        _options.Limit = takeCount;
-        return This;
-    }
-
-    /// <summary>
-    /// Specify how to project the results using a lambda expression
-    /// </summary>
-    /// <param name="expression">x => new Test { PropName = x.Prop }</param>
-    public TSelf Project(Expression<Func<T, TProjection>> expression)
-    {
-        return Project(p => p.Expression(expression));
-    }
-
-    /// <summary>
-    /// Specify how to project the results using a projection expression
-    /// </summary>
-    /// <param name="projection">p => p.Include("Prop1").Exclude("Prop2")</param>
-    public TSelf Project(Func<ProjectionDefinitionBuilder<T>, ProjectionDefinition<T, TProjection>> projection)
-    {
-        _options.Projection = projection(Builders<T>.Projection);
-        return This;
-    }
-
-    /// <summary>
-    /// Specify to automatically include all properties marked with [BsonRequired] attribute on the entity in the final projection.
-    /// <para>HINT: this method should only be called after the .Project() method.</para>
-    /// </summary>
-    public TSelf IncludeRequiredProps()
-    {
-        if (typeof(T) != typeof(TProjection))
-            throw new InvalidOperationException("IncludeRequiredProps() cannot be used when projecting to a different type.");
-
-        _options.Projection = Context.Cache<T>().CombineWithRequiredProps(_options.Projection);
-        return This;
-    }
-
-    /// <summary>
-    /// Specify how to project the results using an exclusion projection expression.
-    /// </summary>
-    /// <param name="exclusion">x => new { x.PropToExclude, x.AnotherPropToExclude }</param>
-    public TSelf ProjectExcluding(Expression<Func<T, object>> exclusion)
-    {
-        var props = (exclusion.Body as NewExpression)?.Arguments
-            .Select(a => a.ToString().Split('.')[1]);
-
-        if (props == null || !props.Any())
-            throw new ArgumentException("Unable to get any properties from the exclusion expression!");
-
-        var defs = new List<ProjectionDefinition<T>>(props.Count());
-
-        foreach (var prop in props)
-        {
-            defs.Add(Builders<T>.Projection.Exclude(prop));
-        }
-
-        _options.Projection = Builders<T>.Projection.Combine(defs);
-
-        return This;
-    }
-
-    /// <summary>
-    /// Specify an option for this find command (use multiple times if needed)
-    /// </summary>
-    /// <param name="option">x => x.OptionName = OptionValue</param>
-    public TSelf Option(Action<FindOptions<T, TProjection>> option)
-    {
-        option(_options);
-        return This;
-    }
-
-    private void AddTxtScoreToProjection(string propName)
-    {
-        if (_options.Projection == null) _options.Projection = "{}";
-
-        _options.Projection =
-            _options.Projection
-            .Render(BsonSerializer.SerializerRegistry.GetSerializer<T>(), BsonSerializer.SerializerRegistry)
-            .Document.Add(propName, new BsonDocument { { "$meta", "textScore" } });
-    }
-
-    /// <summary>
-    /// Sort the results of a text search by the MetaTextScore
-    /// <para>TIP: Use this method after .Project() if you need to do a projection also</para>
-    /// </summary>
-    public TSelf SortByTextScore()
-    {
-        return SortByTextScore(null);
-    }
-
-    /// <summary>
-    /// Sort the results of a text search by the MetaTextScore and get back the score as well
-    /// <para>TIP: Use this method after .Project() if you need to do a projection also</para>
-    /// </summary>
-    /// <param name="scoreProperty">x => x.TextScoreProp</param>
-    public TSelf SortByTextScore(Expression<Func<T, object>>? scoreProperty)
-    {
-        switch (scoreProperty)
-        {
-            case null:
-                AddTxtScoreToProjection("_Text_Match_Score_");
-                return Sort(s => s.MetaTextScore("_Text_Match_Score_"));
-
-            default:
-                AddTxtScoreToProjection(Prop.Path(scoreProperty));
-                return Sort(s => s.MetaTextScore(Prop.Path(scoreProperty)));
-        }
-    }
-}
-
 /// <summary>
 /// Represents a MongoDB Find command.
 /// <para>TIP: Specify your criteria using .Match() .Sort() .Skip() .Take() .Project() .Option() methods and finally call .Execute()</para>
 /// <para>Note: For building queries, use the DB.Fluent* interfaces</para>
 /// </summary>
 /// <typeparam name="T">Any class that implements IEntity</typeparam>
-/// <typeparam name="TId">Id type</typeparam>
-public class Find<T, TId> : Find<T, TId, T>
-    where TId : IComparable<TId>, IEquatable<TId>
-    where T : IEntity<TId>
+public class Find<T> : Find<T, T>
 {
     internal Find(DBContext context, IMongoCollection<T> collection)
         : base(context, collection) { }
 
-    internal Find(DBContext context, IMongoCollection<T> collection, FindBase<T, TId, T, Find<T, TId, T>> baseQuery)
+    internal Find(DBContext context, IMongoCollection<T> collection, FindBase<T, T, Find<T, T>> baseQuery)
         : base(context, collection, baseQuery) { }
 }
 
@@ -167,11 +21,9 @@ internal Find(DBContext context, IMongoCollection<T> collection, FindBase<T, TId
 /// <para>TIP: Specify your criteria using .Match() .Sort() .Skip() .Take() .Project() .Option() methods and finally call .Execute()</para>
 /// </summary>
 /// <typeparam name="T">Any class that implements IEntity</typeparam>
-/// <typeparam name="TId">ID type</typeparam>
 /// <typeparam name="TProjection">The type you'd like to project the results to.</typeparam>
-public class Find<T, TId, TProjection> : FindBase<T, TId, TProjection, Find<T, TId, TProjection>>, ICollectionRelated<T>
-    where TId : IComparable<TId>, IEquatable<TId>
-    where T : IEntity<TId>
+public class Find<T, TProjection> :
+    FindBase<T, TProjection, Find<T, TProjection>>, ICollectionRelated<T>
 {
 
     /// <summary>
@@ -180,7 +32,7 @@ public class Find<T, TId, TProjection> : FindBase<T, TId, TProjection, Find<T, T
     /// <param name="other"></param>
     /// <param name="context"></param>
     /// <param name="collection"></param>
-    internal Find(DBContext context, IMongoCollection<T> collection, FindBase<T, TId, TProjection, Find<T, TId, TProjection>> other) : base(other)
+    internal Find(DBContext context, IMongoCollection<T> collection, FindBase<T, TProjection, Find<T, TProjection>> other) : base(other)
     {
         Context = context;
         Collection = collection;
@@ -196,17 +48,7 @@ internal Find(DBContext context, IMongoCollection<T> collection) : base(context.
 
 
 
-    /// <summary>
-    /// Find a single IEntity by ID
-    /// </summary>
-    /// <param name="ID">The unique ID of an IEntity</param>
-    /// <param name="cancellation">An optional cancellation token</param>
-    /// <returns>A single entity or null if not found</returns>
-    public Task<TProjection> OneAsync(TId ID, CancellationToken cancellation = default)
-    {
-        Match(ID);
-        return ExecuteSingleAsync(cancellation);
-    }
+
 
     /// <summary>
     /// Find entities by supplying a lambda expression
@@ -274,18 +116,7 @@ public async Task<TProjection> ExecuteFirstAsync(CancellationToken cancellation
         return cursor.Current.SingleOrDefault(); //because we're limiting to 1
     }
 
-    /// <summary>
-    /// Run the Find command and get back a bool indicating whether any entities matched the query
-    /// </summary>
-    /// <param name="cancellation">An optional cancellation token</param>
-    public async Task<bool> ExecuteAnyAsync(CancellationToken cancellation = default)
-    {
-        Project(b => b.Include(x => x.ID));
-        Limit(1);
-        using var cursor = await ExecuteCursorAsync(cancellation).ConfigureAwait(false);
-        await cursor.MoveNextAsync(cancellation).ConfigureAwait(false);
-        return cursor.Current.Any();
-    }
+
 
     /// <summary>
     /// Run the Find command in MongoDB server and get a cursor instead of materialized results
@@ -302,8 +133,44 @@ public Task<IAsyncCursor<TProjection>> ExecuteCursorAsync(CancellationToken canc
             Collection.FindAsync(mergedFilter, _options, cancellation) :
             Collection.FindAsync(session, mergedFilter, _options, cancellation);
     }
+
+    /// <summary>
+    /// Run the Find command and get back a bool indicating whether any entities matched the query
+    /// </summary>
+    /// <param name="cancellation">An optional cancellation token</param>
+    public async Task<bool> ExecuteAnyAsync(CancellationToken cancellation = default)
+    {
+        if (Context.Cache<T>().IsEntity)
+        {
+            Project(b => b.Include(nameof(IEntity.ID)));
+        }
+        Limit(1);
+        using var cursor = await ExecuteCursorAsync(cancellation).ConfigureAwait(false);
+        await cursor.MoveNextAsync(cancellation).ConfigureAwait(false);
+        return cursor.Current.Any();
+    }
+
+
 }
 
+public static class FindExt
+{
+    /// <summary>
+    /// Find a single IEntity by ID
+    /// </summary>
+    /// <param name="self"></param>
+    /// <param name="ID">The unique ID of an IEntity</param>
+    /// <param name="cancellation">An optional cancellation token</param>
+    /// <returns>A single entity or null if not found</returns>
+    public static Task<TProjection> OneAsync<TEntity, TId, TProjection, TSelf>(this TSelf self, TId ID, CancellationToken cancellation = default)
+        where TId : IComparable<TId>, IEquatable<TId>
+        where TEntity : IEntity<TId>
+        where TSelf : Find<TEntity, TProjection>, IFilterBuilder<TEntity, TSelf>
+    {
+        self.MatchID<TEntity, TId, TSelf>(ID);
+        return self.ExecuteSingleAsync(cancellation);
+    }
+}
 public enum Order
 {
     Ascending,
diff --git a/MongoDB.Entities/Builders/ICollectionRelated.cs b/MongoDB.Entities/Builders/ICollectionRelated.cs
index 4a31b2ce5..3b28b998c 100644
--- a/MongoDB.Entities/Builders/ICollectionRelated.cs
+++ b/MongoDB.Entities/Builders/ICollectionRelated.cs
@@ -7,6 +7,7 @@ internal interface ICollectionRelated<T>
 }
 internal static class ICollectionRelatedExt
 {
+    public static EntityCache<T> Cache<T>(this ICollectionRelated<T> c) => c.Context.Cache<T>();
     public static IClientSessionHandle? Session<T>(this ICollectionRelated<T> collectionRelated)
     {
         return collectionRelated.Context.Session;
diff --git a/MongoDB.Entities/Builders/Index.Interface.cs b/MongoDB.Entities/Builders/Index.Interface.cs
new file mode 100644
index 000000000..32681a425
--- /dev/null
+++ b/MongoDB.Entities/Builders/Index.Interface.cs
@@ -0,0 +1,22 @@
+
+namespace MongoDB.Entities
+{
+    public interface IIndexBuilder<T, TSelf>
+        where TSelf : IIndexBuilder<T, TSelf>
+    {
+        /// <summary>
+        /// Adds a key definition to the index
+        /// <para>TIP: At least one key definition is required</para>
+        /// </summary>
+        /// <param name="propertyToIndex">x => x.PropertyName</param>
+        /// <param name="type">The type of the key</param>
+        TSelf Key(Expression<Func<T, object>> propertyToIndex, KeyType type);
+
+        /// <summary>
+        /// Set the options for this index definition
+        /// <para>TIP: Setting options is not required.</para>
+        /// </summary>
+        /// <param name="option">x => x.OptionName = OptionValue</param>
+        TSelf Option(Action<CreateIndexOptions<T>> option);
+    }
+}
\ No newline at end of file
diff --git a/MongoDB.Entities/Builders/Index.cs b/MongoDB.Entities/Builders/Index.cs
index 0e1fbf1ca..67610a180 100644
--- a/MongoDB.Entities/Builders/Index.cs
+++ b/MongoDB.Entities/Builders/Index.cs
@@ -4,13 +4,10 @@
 /// Represents an index creation command
 /// <para>TIP: Define the keys first with .Key() method and finally call the .Create() method.</para>
 /// </summary>
-/// <typeparam name="T">Any class that implements IEntity</typeparam>
-/// <typeparam name="TId">Id type</typeparam>
-public class Index<T, TId> : ICollectionRelated<T>
-            where TId : IComparable<TId>, IEquatable<TId>
-    where T : IEntity<TId>
+/// <typeparam name="T">Any class</typeparam>
+public class Index<T> : ICollectionRelated<T>, IIndexBuilder<T, Index<T>>
 {
-    internal List<Key<T, TId>> Keys { get; set; } = new();
+    internal List<Key<T>> Keys { get; set; } = new();
     public DBContext Context { get; }
     public IMongoCollection<T> Collection { get; }
 
@@ -98,26 +95,17 @@ public async Task<string> CreateAsync(CancellationToken cancellation = default)
         return _options.Name;
     }
 
-    /// <summary>
-    /// Set the options for this index definition
-    /// <para>TIP: Setting options is not required.</para>
-    /// </summary>
-    /// <param name="option">x => x.OptionName = OptionValue</param>
-    public Index<T, TId> Option(Action<CreateIndexOptions<T>> option)
+
+    public Index<T> Option(Action<CreateIndexOptions<T>> option)
     {
         option(_options);
         return this;
     }
 
-    /// <summary>
-    /// Adds a key definition to the index
-    /// <para>TIP: At least one key definition is required</para>
-    /// </summary>
-    /// <param name="propertyToIndex">x => x.PropertyName</param>
-    /// <param name="type">The type of the key</param>
-    public Index<T, TId> Key(Expression<Func<T, object>> propertyToIndex, KeyType type)
+
+    public Index<T> Key(Expression<Func<T, object>> propertyToIndex, KeyType type)
     {
-        Keys.Add(new Key<T, TId>(propertyToIndex, type));
+        Keys.Add(new Key<T>(propertyToIndex, type));
         return this;
     }
 
@@ -146,9 +134,7 @@ private Task CreateAsync(CreateIndexModel<T> model, CancellationToken cancellati
     }
 }
 
-internal class Key<T, TId>
-    where TId : IComparable<TId>, IEquatable<TId>
-    where T : IEntity<TId>
+internal class Key<T>
 {
     internal string PropertyName { get; set; }
     internal KeyType Type { get; set; }
diff --git a/MongoDB.Entities/Builders/PagedSearch.cs b/MongoDB.Entities/Builders/PagedSearch.cs
index 73a7f0bb5..99f4941c7 100644
--- a/MongoDB.Entities/Builders/PagedSearch.cs
+++ b/MongoDB.Entities/Builders/PagedSearch.cs
@@ -1,11 +1,14 @@
 namespace MongoDB.Entities;
 
-public class PagedSearchBase<T, TId, TProjection, TSelf> : SortFilterQueryBase<T, TId, TSelf>
-    where TId : IComparable<TId>, IEquatable<TId>
-    where T : IEntity<TId>
-    where TSelf : PagedSearchBase<T, TId, TProjection, TSelf>
+public interface IPagedSearchBuilder<T, TProjection, TSelf> : IProjectionBuilder<T, TProjection, TSelf>
+    where TSelf : IPagedSearchBuilder<T, TProjection, TSelf>
 {
-    internal PagedSearchBase(PagedSearchBase<T, TId, TProjection, TSelf> other) : base(other)
+
+}
+public abstract class PagedSearchBase<T, TProjection, TSelf> : SortFilterQueryBase<T, TSelf>, IPagedSearchBuilder<T, TProjection, TSelf>
+    where TSelf : PagedSearchBase<T, TProjection, TSelf>
+{
+    internal PagedSearchBase(PagedSearchBase<T, TProjection, TSelf> other) : base(other)
     {
     }
 
@@ -163,10 +166,7 @@ public TSelf Option(Action<AggregateOptions> option)
 /// Represents an aggregation query that retrieves results with easy paging support.
 /// </summary>
 /// <typeparam name="T">Any class that implements IEntity</typeparam>
-/// <typeparam name="TId">Id type</typeparam>
-public class PagedSearch<T, TId> : PagedSearch<T, TId, T>
-    where TId : IComparable<TId>, IEquatable<TId>
-    where T : IEntity<TId>
+public class PagedSearch<T> : PagedSearch<T, T>
 {
     internal PagedSearch(
         DBContext context, IMongoCollection<T> collection)
@@ -177,11 +177,8 @@ internal PagedSearch(
 /// Represents an aggregation query that retrieves results with easy paging support.
 /// </summary>
 /// <typeparam name="T">Any class that implements IEntity</typeparam>
-/// <typeparam name="TId">Id type</typeparam>
 /// <typeparam name="TProjection">The type you'd like to project the results to.</typeparam>
-public class PagedSearch<T, TId, TProjection> : PagedSearchBase<T, TId, TProjection, PagedSearch<T, TId, TProjection>>
-    where TId : IComparable<TId>, IEquatable<TId>
-    where T : IEntity<TId>
+public class PagedSearch<T, TProjection> : PagedSearchBase<T, TProjection, PagedSearch<T, TProjection>>, ICollectionRelated<T>
 {
 
     public DBContext Context { get; set; }
@@ -197,6 +194,11 @@ internal PagedSearch(DBContext context, IMongoCollection<T> collection) : base(c
     }
 
 
+    public PagedSearch<T, TProjection> IncludeRequiredProps()
+    {
+        _projectionStage = PipelineStageDefinitionBuilder.Project(this.Cache().CombineWithRequiredProps<TProjection>(_projectionStage?.ToString()));
+        return this;
+    }
 
     /// <summary>
     /// Run the aggregation search command in MongoDB server and get a page of results and total + page count
diff --git a/MongoDB.Entities/Builders/Replace.cs b/MongoDB.Entities/Builders/Replace.cs
index a47d203d0..fa9b34e73 100644
--- a/MongoDB.Entities/Builders/Replace.cs
+++ b/MongoDB.Entities/Builders/Replace.cs
@@ -6,7 +6,7 @@
 /// </summary>
 /// <typeparam name="T">Any class that implements IEntity</typeparam>
 /// <typeparam name="TId">ID type</typeparam>
-public class Replace<T, TId> : FilterQueryBase<T, TId, Replace<T, TId>>, ICollectionRelated<T>
+public class Replace<T, TId> : FilterQueryBase<T, Replace<T, TId>>, ICollectionRelated<T>
     where TId : IComparable<TId>, IEquatable<TId>
     where T : IEntity<TId>
 {
diff --git a/MongoDB.Entities/Builders/SortFilterQueryBase.Interface.cs b/MongoDB.Entities/Builders/SortFilterQueryBase.Interface.cs
new file mode 100644
index 000000000..a3d6c8b14
--- /dev/null
+++ b/MongoDB.Entities/Builders/SortFilterQueryBase.Interface.cs
@@ -0,0 +1,20 @@
+namespace MongoDB.Entities;
+
+public interface ISortBuilder<T, TSelf>
+{
+    internal List<SortDefinition<T>> Sorts { get; }
+
+    /// <summary>
+    /// Specify which property and order to use for sorting (use multiple times if needed)
+    /// </summary>
+    /// <param name="propertyToSortBy">x => x.Prop</param>
+    /// <param name="sortOrder">The sort order</param>
+    public TSelf Sort(Expression<Func<T, object>> propertyToSortBy, Order sortOrder);
+
+    /// <summary>
+    /// Specify how to sort using a sort expression
+    /// </summary>
+    /// <param name="sortFunction">s => s.Ascending("Prop1").MetaTextScore("Prop2")</param>
+    /// <returns></returns>
+    public TSelf Sort(Func<SortDefinitionBuilder<T>, SortDefinition<T>> sortFunction);
+}
diff --git a/MongoDB.Entities/Builders/SortFilterQueryBase.cs b/MongoDB.Entities/Builders/SortFilterQueryBase.cs
index 0a1e97d64..44ab11a56 100644
--- a/MongoDB.Entities/Builders/SortFilterQueryBase.cs
+++ b/MongoDB.Entities/Builders/SortFilterQueryBase.cs
@@ -1,14 +1,14 @@
 namespace MongoDB.Entities;
-
-public abstract class SortFilterQueryBase<T, TId, TSelf> : FilterQueryBase<T, TId, TSelf>
-    where TId : IComparable<TId>, IEquatable<TId>
-    where T : IEntity<TId>
-    where TSelf : SortFilterQueryBase<T, TId, TSelf>
+public abstract class SortFilterQueryBase<T, TSelf> : FilterQueryBase<T, TSelf>,
+    ISortBuilder<T, TSelf>
+    where TSelf : SortFilterQueryBase<T, TSelf>
 {
     internal List<SortDefinition<T>> _sorts = new();
     private TSelf This => (TSelf)this;
 
-    internal SortFilterQueryBase(SortFilterQueryBase<T, TId, TSelf> other) : base(other)
+    List<SortDefinition<T>> ISortBuilder<T, TSelf>.Sorts => _sorts;
+
+    internal SortFilterQueryBase(SortFilterQueryBase<T, TSelf> other) : base(other)
     {
         _sorts = other._sorts;
     }
@@ -42,4 +42,6 @@ public TSelf Sort(Func<SortDefinitionBuilder<T>, SortDefinition<T>> sortFunction
         _sorts.Add(sortFunction(Builders<T>.Sort));
         return This;
     }
+
+
 }
diff --git a/MongoDB.Entities/Core/EntityCache.cs b/MongoDB.Entities/Core/EntityCache.cs
index d230f4f2b..7b1d59987 100644
--- a/MongoDB.Entities/Core/EntityCache.cs
+++ b/MongoDB.Entities/Core/EntityCache.cs
@@ -13,6 +13,8 @@ internal class Cache
     public bool HasIgnoreIfDefaultProps { get; protected set; }
     public string CollectionName { get; protected set; } = null!;
     public bool IsFileEntity { get; protected set; }
+    public bool IsEntity { get; protected set; }
+    public Type? IdType { get; set; }
     protected Cache(Type type)
     {
         var interfaces = type.GetInterfaces();
@@ -24,6 +26,9 @@ protected Cache(Type type)
         if (string.IsNullOrWhiteSpace(CollectionName) || CollectionName.Contains("~"))
             throw new ArgumentException($"{CollectionName} is an illegal name for a collection!");
 
+        var ientityType = interfaces.FirstOrDefault(x => x.IsGenericType && x.GetGenericTypeDefinition() == typeof(IEntity<>));
+        IsEntity = ientityType != null;
+        IdType = ientityType?.GenericTypeArguments.First();
 
         HasCreatedOn = interfaces.Any(i => i == typeof(ICreatedOn));
         HasModifiedOn = interfaces.Any(i => i == typeof(IModifiedOn));
@@ -86,7 +91,10 @@ public ProjectionDefinition<T, TProjection> CombineWithRequiredProps<TProjection
 
         if (_requiredPropsProjection is null)
         {
-            _requiredPropsProjection = "{_id:1}";
+            if (IsEntity)
+            {
+                _requiredPropsProjection = "{_id:1}";
+            }
 
             var props = typeof(T)
                 .GetProperties()
diff --git a/MongoDB.Entities/Core/Prop.cs b/MongoDB.Entities/Core/Prop.cs
index b2291f6c0..eee90367a 100644
--- a/MongoDB.Entities/Core/Prop.cs
+++ b/MongoDB.Entities/Core/Prop.cs
@@ -26,7 +26,7 @@ public static class Prop
         return val;
     }
 
-    private static void ThrowIfInvalid<T>(Expression<Func<T, object>> expression)
+    private static void ThrowIfInvalid<T, TProp>(Expression<Func<T, TProp>> expression)
     {
         if (expression == null)
             throw new ArgumentNullException(nameof(expression), "The supplied expression is null!");
@@ -35,7 +35,7 @@ private static void ThrowIfInvalid<T>(Expression<Func<T, object>> expression)
             throw new ArgumentException("Cannot generate property path from lambda parameter!");
     }
 
-    private static string GetPath<T>(Expression<Func<T, object>> expression)
+    private static string GetPath<T, TProp>(Expression<Func<T, TProp>> expression)
     {
         ThrowIfInvalid(expression);
 
@@ -70,7 +70,7 @@ public static string Property<T>(Expression<Func<T, object>> expression)
     /// <para>EX: Authors[0].Books[0].Title > Authors.Books.Title</para>
     /// </summary>
     /// <param name="expression">x => x.SomeList[0].SomeProp</param>
-    public static string Path<T>(Expression<Func<T, object>> expression)
+    public static string Path<T, TProp>(Expression<Func<T, TProp>> expression)
     {
         return _rxThree.Replace(GetPath(expression), "");
     }
@@ -83,7 +83,7 @@ public static string Path<T>(Expression<Func<T, object>> expression)
     /// <para>TIP: Index positions start from [0] which is converted to $[a] and so on.</para>
     /// </summary>
     /// <param name="expression">x => x.SomeList[0].SomeProp</param>
-    public static string PosFiltered<T>(Expression<Func<T, object>> expression)
+    public static string PosFiltered<T, TProp>(Expression<Func<T, TProp>> expression)
     {
         return _rxFour.Replace(
                         GetPath(expression),
@@ -95,7 +95,7 @@ public static string PosFiltered<T>(Expression<Func<T, object>> expression)
     /// <para>EX: Authors[0].Name > Authors.$[].Name</para>
     /// </summary>
     /// <param name="expression">x => x.SomeList[0].SomeProp</param>
-    public static string PosAll<T>(Expression<Func<T, object>> expression)
+    public static string PosAll<T, TProp>(Expression<Func<T, TProp>> expression)
     {
         return _rxThree.Replace(GetPath(expression), ".$[]");
     }
@@ -105,7 +105,7 @@ public static string PosAll<T>(Expression<Func<T, object>> expression)
     /// <para>EX: Authors[0].Name > Authors.$.Name</para>
     /// </summary>
     /// <param name="expression">x => x.SomeList[0].SomeProp</param>
-    public static string PosFirst<T>(Expression<Func<T, object>> expression)
+    public static string PosFirst<T, TProp>(Expression<Func<T, TProp>> expression)
     {
         return _rxThree.Replace(GetPath(expression), ".$");
     }
@@ -115,7 +115,7 @@ public static string PosFirst<T>(Expression<Func<T, object>> expression)
     /// <para>EX: b => b.Tags > Tags</para>
     /// </summary>
     /// <param name="expression">x => x.SomeProp</param>
-    public static string Elements<T>(Expression<Func<T, object>> expression)
+    public static string Elements<T, TProp>(Expression<Func<T, TProp>> expression)
     {
         return Path(expression);
     }
@@ -128,7 +128,7 @@ public static string Elements<T>(Expression<Func<T, object>> expression)
     /// </summary>
     /// <param name="index">0=a 1=b 2=c 3=d and so on...</param>
     /// <param name="expression">x => x.SomeProp</param>
-    public static string Elements<T>(int index, Expression<Func<T, object>> expression)
+    public static string Elements<T, TProp>(int index, Expression<Func<T, TProp>> expression)
     {
         return $"{ToLowerCaseLetter(index)}.{Path(expression)}";
     }
diff --git a/MongoDB.Entities/DBContext/DBContext.Find.cs b/MongoDB.Entities/DBContext/DBContext.Find.cs
index e8cedbc27..3eac92376 100644
--- a/MongoDB.Entities/DBContext/DBContext.Find.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Find.cs
@@ -8,24 +8,18 @@ public partial class DBContext
     /// Starts a find command for the given entity type
     /// </summary>
     /// <typeparam name="T">The type of entity</typeparam>
-    /// <typeparam name="TId">ID type</typeparam>
-    public Find<T, TId> Find<T, TId>(string? collectionName = null, IMongoCollection<T>? collection = null)
-        where TId : IComparable<TId>, IEquatable<TId>
-        where T : IEntity<TId>
+    public Find<T> Find<T>(string? collectionName = null, IMongoCollection<T>? collection = null)
     {
-        return new Find<T, TId>(this, Collection(collectionName, collection));
+        return new Find<T>(this, Collection(collectionName, collection));
     }
 
     /// <summary>
     /// Starts a find command with projection support for the given entity type
     /// </summary>
-    /// <typeparam name="T">The type of entity</typeparam>
-    /// <typeparam name="TId">ID type</typeparam>
+    /// <typeparam name="T">The type of entity</typeparam>    
     /// <typeparam name="TProjection">The type of the end result</typeparam>
-    public Find<T, TId, TProjection> Find<T, TId, TProjection>(string? collectionName = null, IMongoCollection<T>? collection = null)
-        where TId : IComparable<TId>, IEquatable<TId>
-        where T : IEntity<TId>
+    public Find<T, TProjection> Find<T,  TProjection>(string? collectionName = null, IMongoCollection<T>? collection = null)
     {
-        return new Find<T, TId, TProjection>(this, Collection(collectionName, collection));
+        return new Find<T, TProjection>(this, Collection(collectionName, collection));
     }
 }
diff --git a/MongoDB.Entities/Extensions/Entity.cs b/MongoDB.Entities/Extensions/Entity.cs
index 388b0dc09..4c26ec4e2 100644
--- a/MongoDB.Entities/Extensions/Entity.cs
+++ b/MongoDB.Entities/Extensions/Entity.cs
@@ -35,6 +35,7 @@ internal static void ThrowIfUnsaved<TId>(this TId? id) where TId : IComparable<T
             if ((id is string strId && string.IsNullOrWhiteSpace(strId)) || EqualityComparer<TId?>.Default.Equals(id, default))
                 throw new InvalidOperationException("Please save the entity before performing this operation!");
         }
+
         internal static void ThrowIfUnsaved<TId>(this IEntity<TId> entity) where TId : IComparable<TId>, IEquatable<TId>
         {
             ThrowIfUnsaved(entity.ID);
@@ -66,8 +67,9 @@ public static IEnumerable<IEnumerable<T>> ToBatches<T>(this IEnumerable<T> colle
         /// <summary>
         /// Returns the full dotted path of a property for the given expression
         /// </summary>
-        /// <typeparam name="T">Any class that implements IEntity</typeparam>
-        public static string FullPath<T>(this Expression<Func<T, object>> expression)
+        /// <typeparam name="T">Any class</typeparam>
+        /// <typeparam name="TProp">Property type</typeparam>
+        public static string FullPath<T, TProp>(this Expression<Func<T, TProp>> expression)
         {
             return Prop.Path(expression);
         }
@@ -75,7 +77,7 @@ public static string FullPath<T>(this Expression<Func<T, object>> expression)
         /// <summary>
         /// An IQueryable collection of sibling Entities.
         /// </summary>
-        public static IMongoQueryable<T> Queryable<T>(this T _, AggregateOptions? options = null, string tenantPrefix = null) where T : IEntity
+        public static IMongoQueryable<T> Queryable<T>(this T _, AggregateOptions? options = null, string? tenantPrefix = null) where T : IEntity
         {
             return DB.Queryable<T>(options);
         }
diff --git a/MongoDB.Entities/GlobalUsing.cs b/MongoDB.Entities/GlobalUsing.cs
index 31b77f63a..a343aca18 100644
--- a/MongoDB.Entities/GlobalUsing.cs
+++ b/MongoDB.Entities/GlobalUsing.cs
@@ -6,3 +6,5 @@
 global using MongoDB.Bson.Serialization.Serializers;
 global using MongoDB.Driver.Linq;
 global using System.Reflection;
+
+global using System.Diagnostics.CodeAnalysis;
diff --git a/MongoDB.Entities/MongoDB.Entities.csproj b/MongoDB.Entities/MongoDB.Entities.csproj
index 50395ab3c..02926f487 100644
--- a/MongoDB.Entities/MongoDB.Entities.csproj
+++ b/MongoDB.Entities/MongoDB.Entities.csproj
@@ -11,7 +11,7 @@
 			- upgrade dependencies
 		</PackageReleaseNotes>
 
-		<TargetFramework>netstandard2.0</TargetFramework>
+		<TargetFramework>netstandard2.1</TargetFramework>
 		<RootNamespace>MongoDB.Entities</RootNamespace>
 		<AssemblyName>MongoDB.Entities</AssemblyName>
 		<Authors>Đĵ ΝιΓΞΗΛψΚ</Authors>
diff --git a/MongoDB.Entities/Relationships/NewMany.cs b/MongoDB.Entities/Relationships/NewMany.cs
index b757feb51..dc4a91654 100644
--- a/MongoDB.Entities/Relationships/NewMany.cs
+++ b/MongoDB.Entities/Relationships/NewMany.cs
@@ -74,44 +74,25 @@
 //    public override Guid GenerateNewID() => Guid.NewGuid();
 //}
 
-public interface IManyS<TChild> : IMany<TChild, string>
-    where TChild : IEntity
+public interface IMany<TChild>
 {
-
-}
-public interface IMany<TChild, TChildId>
-    where TChild : IEntity<TChildId>
-    where TChildId : IComparable<TChildId>, IEquatable<TChildId>
-{
-    Find<TChild, TChildId, TChild> GetChildrenFind(DBContext context, string? childCollectionName = null, IMongoCollection<TChild>? collection = null);
-    Find<TChild, TChildId, TProjection> GetChildrenFind<TProjection>(DBContext context, string? childCollectionName = null, IMongoCollection<TChild>? collection = null);
+    Find<TChild, TChild> GetChildrenFind(DBContext context, string? childCollectionName = null, IMongoCollection<TChild>? collection = null);
+    Find<TChild, TProjection> GetChildrenFind<TProjection>(DBContext context, string? childCollectionName = null, IMongoCollection<TChild>? collection = null);
     IMongoQueryable<TChild> GetChildrenQuery(DBContext context, string? childCollectionName = null, IMongoCollection<TChild>? collection = null);
 }
 
-public interface IMany<TParent, TParentId, TChild, TChildId> : IMany<TChild, TChildId>
-    where TParent : IEntity<TParentId>
-    where TParentId : IComparable<TParentId>, IEquatable<TParentId>
-    where TChild : IEntity<TChildId>
-    where TChildId : IComparable<TChildId>, IEquatable<TChildId>
+public interface IMany<TParent, TChild> : IMany<TChild>
 {
     TParent Parent { get; }
 
     FilterDefinition<TChild> GetFilterForSingleDocument();
 }
 
-public interface IManyToMany<TParent, TParentId, TChild, TChildId> : IMany<TParent, TParentId, TChild, TChildId>
-    where TParent : IEntity<TParentId>
-    where TParentId : IComparable<TParentId>, IEquatable<TParentId>
-    where TChild : IEntity<TChildId>
-    where TChildId : IComparable<TChildId>, IEquatable<TChildId>
+public interface IManyToMany<TParent, TChild> : IMany<TParent, TChild>
 {
     bool IsParentOwner { get; }
 }
-public interface IManyToOne<TParent, TParentId, TChild, TChildId> : IMany<TParent, TParentId, TChild, TChildId>
-    where TParent : IEntity<TParentId>
-    where TParentId : IComparable<TParentId>, IEquatable<TParentId>
-    where TChild : IEntity<TChildId>
-    where TChildId : IComparable<TChildId>, IEquatable<TChildId>
+public interface IManyToOne<TParent, TChild> : IMany<TParent, TChild>
 {
 }
 
@@ -121,9 +102,7 @@ public interface IManyToOne<TParent, TParentId, TChild, TChildId> : IMany<TParen
 /// </summary>
 /// <typeparam name="TChild"></typeparam>
 /// <typeparam name="TChildId"></typeparam>
-public abstract class Many<TChild, TChildId> : IMany<TChild, TChildId>
-    where TChildId : IComparable<TChildId>, IEquatable<TChildId>
-    where TChild : IEntity<TChildId>
+public abstract class Many<TChild> : IMany<TChild>
 {
     protected Many(PropertyInfo parentProperty, PropertyInfo childProperty)
     {
@@ -135,14 +114,10 @@ protected Many(PropertyInfo parentProperty, PropertyInfo childProperty)
     internal PropertyInfo ChildProperty { get; }
 
     public abstract IMongoQueryable<TChild> GetChildrenQuery(DBContext context, string? childCollectionName = null, IMongoCollection<TChild>? collection = null);
-    public Find<TChild, TChildId, TChild> GetChildrenFind(DBContext context, string? childCollectionName = null, IMongoCollection<TChild>? collection = null) => GetChildrenFind<TChild>(context, childCollectionName, collection);
-    public abstract Find<TChild, TChildId, TProjection> GetChildrenFind<TProjection>(DBContext context, string? childCollectionName = null, IMongoCollection<TChild>? collection = null);
+    public Find<TChild, TChild> GetChildrenFind(DBContext context, string? childCollectionName = null, IMongoCollection<TChild>? collection = null) => GetChildrenFind<TChild>(context, childCollectionName, collection);
+    public abstract Find<TChild, TProjection> GetChildrenFind<TProjection>(DBContext context, string? childCollectionName = null, IMongoCollection<TChild>? collection = null);
 }
-public abstract class Many<TParent, TParentId, TChild, TChildId> : Many<TChild, TChildId>, IMany<TParent, TParentId, TChild, TChildId>
-    where TParent : IEntity<TParentId>
-    where TParentId : IComparable<TParentId>, IEquatable<TParentId>
-    where TChild : IEntity<TChildId>
-    where TChildId : IComparable<TChildId>, IEquatable<TChildId>
+public abstract class Many<TParent, TChild> : Many<TChild>, IMany<TParent, TChild>
 {
     public TParent Parent { get; }
     protected Many(TParent parent, PropertyInfo parentProperty, PropertyInfo childProperty) : base(parentProperty, childProperty)
@@ -150,15 +125,9 @@ protected Many(TParent parent, PropertyInfo parentProperty, PropertyInfo childPr
         Parent = parent;
     }
     public FilterDefinition<TChild> GetFilterForSingleDocument() => Builders<TChild>.Filter.Eq(ChildProperty.Name, Parent.ID);
-
-
 }
 
-public sealed class ManyToMany<TParent, TParentId, TChild, TChildId> : Many<TParent, TParentId, TChild, TChildId>, IManyToMany<TParent, TParentId, TChild, TChildId>
-    where TParent : IEntity<TParentId>
-    where TParentId : IComparable<TParentId>, IEquatable<TParentId>
-    where TChild : IEntity<TChildId>
-    where TChildId : IComparable<TChildId>, IEquatable<TChildId>
+public sealed class ManyToMany<TParent, TChild> : Many<TParent, TChild>, IManyToMany<TParent, TChild>
 {
     public ManyToMany(bool isParentOwner, TParent parent, PropertyInfo parentProperty, PropertyInfo childProperty) : base(parent, parentProperty, childProperty)
     {
@@ -167,7 +136,7 @@ public ManyToMany(bool isParentOwner, TParent parent, PropertyInfo parentPropert
 
     public bool IsParentOwner { get; }
 
-    public override Find<TChild, TChildId, TProjection> GetChildrenFind<TProjection>(DBContext context, string? childCollectionName = null, IMongoCollection<TChild>? collection = null)
+    public override Find<TChild, TProjection> GetChildrenFind<TProjection>(DBContext context, string? childCollectionName = null, IMongoCollection<TChild>? collection = null)
     {
         throw new NotImplementedException();
     }
@@ -178,19 +147,15 @@ public override IMongoQueryable<TChild> GetChildrenQuery(DBContext context, stri
     }
 }
 
-public sealed class ManyToOne<TParent, TParentId, TChild, TChildId> : Many<TParent, TParentId, TChild, TChildId>, IManyToOne<TParent, TParentId, TChild, TChildId>
-    where TParent : IEntity<TParentId>
-    where TParentId : IComparable<TParentId>, IEquatable<TParentId>
-    where TChild : IEntity<TChildId>
-    where TChildId : IComparable<TChildId>, IEquatable<TChildId>
+public sealed class ManyToOne<TParent, TChild> : Many<TParent, TChild>, IManyToOne<TParent, TChild>
 {
     public ManyToOne(TParent parent, PropertyInfo parentProperty, PropertyInfo childProperty) : base(parent, parentProperty, childProperty)
     {
     }
 
-    public override Find<TChild, TChildId, TProjection> GetChildrenFind<TProjection>(DBContext context, string? childCollectionName = null, IMongoCollection<TChild>? childCollection = null)
+    public override Find<TChild, TProjection> GetChildrenFind<TProjection>(DBContext context, string? childCollectionName = null, IMongoCollection<TChild>? childCollection = null)
     {
-        return context.Find<TChild, TChildId, TProjection>(childCollectionName, childCollection)
+        return context.Find<TChild, TProjection>(childCollectionName, childCollection)
             .Match(GetFilterForSingleDocument()); //BRef==Parent.Id
     }
 
@@ -229,7 +194,7 @@ public static PropertyInfo GetPropertyInfo<TSource, TProperty>(this Expression<F
         return propInfo;
     }
 
-    public static IManyToMany<TParent, TParentId, TChild, TChildId> InitManyToMany<TParent, TParentId, TChild, TChildId>(this TParent parent, Expression<Func<TParent, IMany<TChild, TChildId>>> propertyExpression, Expression<Func<TChild, IMany<TParent, TParentId>>> propertyOtherSide)
+    public static IManyToMany<TParent, TChild> InitManyToMany<TParent, TParentId, TChild, TChildId>(this TParent parent, Expression<Func<TParent, IMany<TChild, TChildId>>> propertyExpression, Expression<Func<TChild, IMany<TParent, TParentId>>> propertyOtherSide)
         where TParent : IEntity<TParentId>
         where TParentId : IComparable<TParentId>, IEquatable<TParentId>
         where TChild : IEntity<TChildId>
@@ -248,13 +213,13 @@ public static IManyToMany<TParent, TParentId, TChild, TChildId> InitManyToMany<T
         if (!osHasOwnerAttrib && !osHasInverseAttrib) throw new InvalidOperationException("Missing attribute for determining relationship side of a many-to-many relationship");
 
         if ((hasOwnerAttrib == osHasOwnerAttrib) || (hasInverseAttrib == osHasInverseAttrib)) throw new InvalidOperationException("Both sides of the relationship cannot have the same attribute");
-        var res = new ManyToMany<TParent, TParentId, TChild, TChildId>(hasInverseAttrib, parent, property, osProperty);
+        var res = new ManyToMany<TParent, TChild>(hasInverseAttrib, parent, property, osProperty);
         //should we set the property ourself or let the user handle it ?
         //property.SetValue(parent, res);
         return res;
     }
-    public static IManyToOne<TParent, TParentId, TChild, TChildId> InitManyToOne<TParent, TParentId, TChild, TChildId>(this TParent parent, Expression<Func<TParent, IMany<TChild, TChildId>>> propertyExpression, Expression<Func<TChild, One<TParent, TParentId>?>> propertyOtherSide)
-        where TParent : IEntity<TParentId>
+    public static IManyToOne<TParent, TChild> InitManyToOne<TParent, TParentId, TChild, TChildId>(this TParent parent, Expression<Func<TParent, IMany<TChild, TChildId>>> propertyExpression, Expression<Func<TChild, One<TParent, TParentId>?>> propertyOtherSide)
+          where TParent : IEntity<TParentId>
         where TParentId : IComparable<TParentId>, IEquatable<TParentId>
         where TChild : IEntity<TChildId>
         where TChildId : IComparable<TChildId>, IEquatable<TChildId>
@@ -262,6 +227,6 @@ public static IManyToOne<TParent, TParentId, TChild, TChildId> InitManyToOne<TPa
         var property = propertyExpression.GetPropertyInfo();
         var osProperty = propertyOtherSide.GetPropertyInfo();
 
-        return new ManyToOne<TParent, TParentId, TChild, TChildId>(parent, property, osProperty);
+        return new ManyToOne<TParent, TChild>(parent, property, osProperty);
     }
 }
\ No newline at end of file
diff --git a/MongoDB.Entities/Relationships/One.cs b/MongoDB.Entities/Relationships/One.cs
index 3e9544e3b..df2f4b3fb 100644
--- a/MongoDB.Entities/Relationships/One.cs
+++ b/MongoDB.Entities/Relationships/One.cs
@@ -1,147 +1,177 @@
 using MongoDB.Driver;
 using System;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Linq.Expressions;
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace MongoDB.Entities
+namespace MongoDB.Entities;
+public interface IOneRelation<T>
 {
+    T? Cache { get; set; }
+}
+/// <summary>
+/// Represents a one-to-x relationship.
+/// Note: this doesn't get serialized nor store any information, it just marks a related entity
+/// </summary>
+/// <typeparam name="T">Any type</typeparam>
+public class One<T> : IOneRelation<T>
+{
+    [BsonIgnore]
+    public T? Cache { get; set; }
+
+    public One()
+    {
+    }
+
     /// <summary>
-    /// Represents a one-to-one relationship with an IEntity.
+    /// Initializes a reference to an entity in MongoDB.
     /// </summary>
-    /// <typeparam name="T">Any type that implements IEntity</typeparam>
-    /// <typeparam name="TId">Any type that implements IEntity</typeparam>
-    public class One<T, TId>
-        where TId : IComparable<TId>, IEquatable<TId>
-        where T : IEntity<TId>
+    /// <param name="entity">The actual entity this reference represents.</param>
+    internal One(T entity)
     {
-        private T? _cache;
+        Cache = entity;
+    }
 
-        /// <summary>
-        /// The Id of the entity referenced by this instance.
-        /// </summary>
-        [AsObjectId]
-        public TId? ID { get; set; }
 
-        public T? Cache
-        {
-            get => _cache;
-            set
-            {
-                value?.ThrowIfUnsaved();
-                _cache = value;
-                if (value is not null)
-                {
-                    if (!EqualityComparer<TId?>.Default.Equals(ID, value.ID))
-                    {
-                        ID = value.ID!;
-                    }
-                }
-                else
-                {
-                    ID = default;
-                }
-            }
-        }
+    /// <summary>
+    /// Operator for returning a new MarkerOne&lt;T&gt; object from an entity
+    /// </summary>
+    /// <param name="entity">The entity to make a reference to</param>
+    public static implicit operator One<T>(T entity)
+    {
+        return new One<T>(entity);
+    }
 
-        public One()
-        {
-        }
+    /// <summary>
+    /// Returns a find for the related entity
+    /// </summary>
+    /// <param name="context"></param>
+    /// <param name="filter"></param>
+    /// <param name="collectionName"></param>
+    /// <param name="collection"></param>
+    /// <returns></returns>
+    public Find<T, T> ToFind(DBContext context, FilterDefinition<T> filter, string? collectionName = null, IMongoCollection<T>? collection = null)
+    {
+        return context.Find(collectionName, collection).Match(filter);
+    }
 
-        /// <summary>
-        /// Initializes a reference to an entity in MongoDB.
-        /// </summary>
-        /// <param name="entity">The actual entity this reference represents.</param>
-        internal One(T entity)
-        {
-            Cache = entity;
-        }
+    ///// <summary>
+    ///// Fetches the actual entity this reference represents from the database.
+    ///// </summary>
+    ///// <param name="context"></param>
+    ///// <param name="cancellation">An optional cancellation token</param>
+    ///// <param name="collectionName"></param>
+    ///// <param name="collection"></param>
+    ///// <returns>A Task containing the actual entity</returns>
+    //public async Task<T?> ToEntityAsync(DBContext context, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null)
+    //{
+    //    if (ID is null)
+    //    {
+    //        return default;
+    //    }
 
-        /// <summary>
-        /// Operator for returning a new One&lt;T&gt; object from a string ID
-        /// </summary>
-        /// <param name="id">The ID to create a new One&lt;T&gt; with</param>
-        public static implicit operator One<T, TId>(TId id)
-        {
-            return new One<T, TId>() { ID = id };
-        }
+    //    return Cache = context.Find(collectionName, collection).OneAsync(ID, cancellation);
+    //}
 
-        /// <summary>
-        /// Operator for returning a new One&lt;T&gt; object from an entity
-        /// </summary>
-        /// <param name="entity">The entity to make a reference to</param>
-        public static implicit operator One<T, TId>(T entity)
-        {
-            return new One<T, TId>(entity);
-        }
+    ///// <summary>
+    ///// Fetches the actual entity this reference represents from the database with a projection.
+    ///// </summary>
+    ///// <param name="context"></param>
+    ///// <param name="projection">x => new Test { PropName = x.Prop }</param>
+    ///// <param name = "cancellation" > An optional cancellation token</param>
+    ///// <param name="collectionName"></param>
+    ///// <param name="collection"></param>
+    ///// <returns>A Task containing the actual projected entity</returns>
+    //public async Task<TTo?> ToEntityAsync<TTo>(DBContext context, Expression<Func<T, TTo>> projection, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null)
+    //{
+    //    if (ID is null)
+    //    {
+    //        return default;
+    //    }
 
-        /// <summary>
-        /// Fetches the actual entity this reference represents from the database.
-        /// </summary>
-        /// <param name="context"></param>
-        /// <param name="cancellation">An optional cancellation token</param>
-        /// <param name="collectionName"></param>
-        /// <param name="collection"></param>
-        /// <returns>A Task containing the actual entity</returns>
-        public async Task<T?> ToEntityAsync(DBContext context, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null)
-        {
-            if (ID is null)
-            {
-                return default;
-            }
+    //    return (await context.Find<T, TTo>(collectionName, collection)
+    //                .MatchID(ID)
+    //                .Project(projection)
+    //                .ExecuteAsync(cancellation).ConfigureAwait(false))
+    //           .SingleOrDefault();
+    //}
 
-            return Cache = await new Find<T, TId>(context, collection ?? context.Collection<T>(collectionName)).OneAsync(ID, cancellation);
-        }
+    ///// <summary>
+    ///// Fetches the actual entity this reference represents from the database with a projection.
+    ///// </summary>
+    ///// <param name="context"></param>
+    ///// <param name="projection">p=> p.Include("Prop1").Exclude("Prop2")</param>
+    ///// <param name = "cancellation" > An optional cancellation token</param>
+    ///// <param name="collectionName"></param>
+    ///// <param name="collection"></param>
+    ///// <returns>A Task containing the actual projected entity</returns>
+    //public async Task<TTo?> ToEntityAsync<TTo>(DBContext context, Func<ProjectionDefinitionBuilder<T>, ProjectionDefinition<T, TTo>> projection, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null)
+    //{
+    //    if (ID is null)
+    //    {
+    //        return default;
+    //    }
+    //    return (await new Find<T, TId, TTo>(context, collection ?? context.Collection<T>(collectionName))
+    //                .Match(ID)
+    //                .Project(projection)
+    //                .ExecuteAsync(cancellation).ConfigureAwait(false))
+    //           .SingleOrDefault();
+    //}
+}
 
-        /// <summary>
-        /// Fetches the actual entity this reference represents from the database with a projection.
-        /// </summary>
-        /// <param name="context"></param>
-        /// <param name="projection">x => new Test { PropName = x.Prop }</param>
-        /// <param name = "cancellation" > An optional cancellation token</param>
-        /// <param name="collectionName"></param>
-        /// <param name="collection"></param>
-        /// <returns>A Task containing the actual projected entity</returns>
-        public async Task<TTo?> ToEntityAsync<TTo>(DBContext context, Expression<Func<T, TTo>> projection, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null)
+/// <summary>
+/// Represents a one-to-x relationship with a known Id.
+/// This DOES get serialized to
+/// {
+///     "ID" : "xxxxxxxx"
+/// }
+/// </summary>
+/// <typeparam name="T"></typeparam>
+/// <typeparam name="TId"></typeparam>
+public class One<T, TId> : IOneRelation<T>
+    where T : IEntity<TId>
+    where TId : IComparable<TId>, IEquatable<TId>
+{
+    private T? _cache;
+
+    [BsonIgnore]
+    public T? Cache
+    {
+        get => _cache;
+        set
         {
-            if (ID is null)
+            value?.ThrowIfUnsaved();
+            _cache = value;
+            if (value is not null)
             {
-                return default;
+                if (!EqualityComparer<TId?>.Default.Equals(ID, value.ID))
+                {
+                    ID = value.ID!;
+                }
             }
-
-            return (await new Find<T, TId, TTo>(context, collection ?? context.Collection<T>(collectionName))
-                        .Match(ID)
-                        .Project(projection)
-                        .ExecuteAsync(cancellation).ConfigureAwait(false))
-                   .SingleOrDefault();
-        }
-
-        /// <summary>
-        /// Fetches the actual entity this reference represents from the database with a projection.
-        /// </summary>
-        /// <param name="context"></param>
-        /// <param name="projection">p=> p.Include("Prop1").Exclude("Prop2")</param>
-        /// <param name = "cancellation" > An optional cancellation token</param>
-        /// <param name="collectionName"></param>
-        /// <param name="collection"></param>
-        /// <returns>A Task containing the actual projected entity</returns>
-        public async Task<TTo?> ToEntityAsync<TTo>(DBContext context, Func<ProjectionDefinitionBuilder<T>, ProjectionDefinition<T, TTo>> projection, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null)
-        {
-            if (ID is null)
+            else
             {
-                return default;
+                ID = default;
             }
-            return (await new Find<T, TId, TTo>(context, collection ?? context.Collection<T>(collectionName))
-                        .Match(ID)
-                        .Project(projection)
-                        .ExecuteAsync(cancellation).ConfigureAwait(false))
-                   .SingleOrDefault();
         }
     }
 
-    public class One<T> : One<T, string> where T : IEntity
+    public TId? ID { get; set; }
+
+    public One()
     {
 
     }
-}
+    public One(TId id)
+    {
+        ID = id;
+    }
+    public One(T entity)
+    {
+        entity.ThrowIfUnsaved();
+        _cache = entity;
+        ID = entity.ID;
+    }
+}
\ No newline at end of file
diff --git a/Tests/TestModifiedBy.cs b/Tests/TestModifiedBy.cs
index 33ca4b3ba..1f5844e8b 100644
--- a/Tests/TestModifiedBy.cs
+++ b/Tests/TestModifiedBy.cs
@@ -13,7 +13,7 @@ public async Task throw_if_mod_by_not_supplied()
         {
             var db = new DBContext();
             await Assert.ThrowsExceptionAsync<InvalidOperationException>(
-                async () => await db.SaveAsync(new Author()));
+                async () => await db.SaveAsync<Author, string>(new Author()));
         }
 
         [TestMethod]

From 44678156ec35671830d572f8a3feb6ebfb809e03 Mon Sep 17 00:00:00 2001
From: Ahmed Fwela <ahmednfwela@bdaya-dev.com>
Date: Tue, 28 Dec 2021 05:56:46 +0200
Subject: [PATCH 24/26] remove static API

---
 MongoDB.Entities/DB/DB.Collection.cs  |  56 -------------
 MongoDB.Entities/DB/DB.Count.cs       |  68 ---------------
 MongoDB.Entities/DB/DB.Delete.cs      |  81 ------------------
 MongoDB.Entities/DB/DB.Distinct.cs    |  16 ----
 MongoDB.Entities/DB/DB.File.cs        |  18 ----
 MongoDB.Entities/DB/DB.Find.cs        |  24 ------
 MongoDB.Entities/DB/DB.Fluent.cs      |  32 --------
 MongoDB.Entities/DB/DB.GeoNear.cs     |  29 -------
 MongoDB.Entities/DB/DB.Index.cs       |  17 ----
 MongoDB.Entities/DB/DB.Insert.cs      |  36 --------
 MongoDB.Entities/DB/DB.Migrate.cs     |  25 +++---
 MongoDB.Entities/DB/DB.PagedSearch.cs |  26 ------
 MongoDB.Entities/DB/DB.Pipeline.cs    |  67 ---------------
 MongoDB.Entities/DB/DB.Queryable.cs   |  18 ----
 MongoDB.Entities/DB/DB.Replace.cs     |  17 ----
 MongoDB.Entities/DB/DB.Save.cs        | 114 --------------------------
 MongoDB.Entities/DB/DB.Sequence.cs    |  30 -------
 MongoDB.Entities/DB/DB.Transaction.cs |  30 -------
 MongoDB.Entities/DB/DB.Update.cs      |  32 --------
 MongoDB.Entities/DB/DB.Watcher.cs     |  25 ------
 20 files changed, 11 insertions(+), 750 deletions(-)
 delete mode 100644 MongoDB.Entities/DB/DB.Collection.cs
 delete mode 100644 MongoDB.Entities/DB/DB.Count.cs
 delete mode 100644 MongoDB.Entities/DB/DB.Delete.cs
 delete mode 100644 MongoDB.Entities/DB/DB.Distinct.cs
 delete mode 100644 MongoDB.Entities/DB/DB.File.cs
 delete mode 100644 MongoDB.Entities/DB/DB.Find.cs
 delete mode 100644 MongoDB.Entities/DB/DB.Fluent.cs
 delete mode 100644 MongoDB.Entities/DB/DB.GeoNear.cs
 delete mode 100644 MongoDB.Entities/DB/DB.Index.cs
 delete mode 100644 MongoDB.Entities/DB/DB.Insert.cs
 delete mode 100644 MongoDB.Entities/DB/DB.PagedSearch.cs
 delete mode 100644 MongoDB.Entities/DB/DB.Pipeline.cs
 delete mode 100644 MongoDB.Entities/DB/DB.Queryable.cs
 delete mode 100644 MongoDB.Entities/DB/DB.Replace.cs
 delete mode 100644 MongoDB.Entities/DB/DB.Save.cs
 delete mode 100644 MongoDB.Entities/DB/DB.Sequence.cs
 delete mode 100644 MongoDB.Entities/DB/DB.Transaction.cs
 delete mode 100644 MongoDB.Entities/DB/DB.Update.cs
 delete mode 100644 MongoDB.Entities/DB/DB.Watcher.cs

diff --git a/MongoDB.Entities/DB/DB.Collection.cs b/MongoDB.Entities/DB/DB.Collection.cs
deleted file mode 100644
index b0b98539d..000000000
--- a/MongoDB.Entities/DB/DB.Collection.cs
+++ /dev/null
@@ -1,56 +0,0 @@
-using MongoDB.Driver;
-using System;
-using System.Collections.Generic;
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace MongoDB.Entities
-{
-    public static partial class DB
-    {
-        internal static IMongoCollection<JoinRecord<string, string>> GetRefCollection<T>(string name) where T : IEntity
-        {
-            return Context.GetCollection<JoinRecord<string, string>>(name);
-        }
-
-        /// <summary>
-        /// Gets the IMongoCollection for a given IEntity type.
-        /// </summary>
-        /// <typeparam name="T">Any class that implements IEntity</typeparam>
-        /// <param name="collectionName">Optionally use a specific collection name</param>
-        public static IMongoCollection<T> Collection<T>(string? collectionName = null) where T : IEntity
-        {
-            return Context.Collection<T>(collectionName);
-        }
-
-        /// <summary>
-        /// Gets the collection name for a given entity type
-        /// </summary>
-        /// <typeparam name="T">The type of entity to get the collection name for</typeparam>
-        public static string CollectionName<T>() where T : IEntity
-        {
-            return Context.CollectionName<T>();
-        }
-
-        /// <summary>
-        /// Creates a collection for an Entity type explicitly using the given options
-        /// </summary>
-        /// <typeparam name="T">The type of entity that will be stored in the created collection</typeparam>
-        /// <param name="options">The options to use for collection creation</param>
-        /// <param name="cancellation">An optional cancellation token</param>
-        public static Task CreateCollectionAsync<T>(Action<CreateCollectionOptions<T>> options, CancellationToken cancellation = default) where T : IEntity
-        {
-            return Context.CreateCollectionAsync(options, cancellation);
-        }
-
-        /// <summary>
-        /// Deletes the collection of a given entity type as well as the join collections for that entity.
-        /// <para>TIP: When deleting a collection, all relationships associated with that entity type is also deleted.</para>
-        /// </summary>
-        /// <typeparam name="T">The entity type to drop the collection of</typeparam>
-        public static async Task DropCollectionAsync<T>() where T : IEntity
-        {
-            await Context.DropCollectionAsync<T>();
-        }
-    }
-}
diff --git a/MongoDB.Entities/DB/DB.Count.cs b/MongoDB.Entities/DB/DB.Count.cs
deleted file mode 100644
index 56aa6c5fb..000000000
--- a/MongoDB.Entities/DB/DB.Count.cs
+++ /dev/null
@@ -1,68 +0,0 @@
-using MongoDB.Driver;
-using System;
-using System.Linq.Expressions;
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace MongoDB.Entities
-{
-    public static partial class DB
-    {
-        /// <summary>
-        /// Gets a fast estimation of how many documents are in the collection using metadata.
-        /// <para>HINT: The estimation may not be exactly accurate.</para>
-        /// </summary>
-        /// <typeparam name="T">The entity type to get the count for</typeparam>
-        /// <param name="cancellation">An optional cancellation token</param>
-        public static Task<long> CountEstimatedAsync<T>(CancellationToken cancellation = default) where T : IEntity
-        {
-            return Context.CountEstimatedAsync<T>(cancellation);
-        }
-
-        /// <summary>
-        /// Gets an accurate count of how many entities are matched for a given expression/filter
-        /// </summary>
-        /// <typeparam name="T">The entity type to get the count for</typeparam>
-        /// <param name="expression">A lambda expression for getting the count for a subset of the data</param>
-        /// <param name="cancellation">An optional cancellation token</param>
-        /// <param name="options">An optional CountOptions object</param>
-        public static Task<long> CountAsync<T>(Expression<Func<T, bool>> expression, CancellationToken cancellation = default, CountOptions? options = null) where T : IEntity
-        {
-            return Context.CountAsync(expression, cancellation, options);
-        }
-
-        /// <summary>
-        /// Gets an accurate count of how many total entities are in the collection for a given entity type
-        /// </summary>
-        /// <typeparam name="T">The entity type to get the count for</typeparam>
-        /// <param name="filter">A filter definition</param>
-        /// <param name="cancellation">An optional cancellation token</param>
-        /// <param name="options">An optional CountOptions object</param>
-        public static Task<long> CountAsync<T>(FilterDefinition<T> filter, CancellationToken cancellation = default, CountOptions? options = null) where T : IEntity
-        {
-            return Context.CountAsync(filter, cancellation, options);
-        }
-
-        /// <summary>
-        /// Gets an accurate count of how many total entities are in the collection for a given entity type
-        /// </summary>
-        /// <typeparam name="T">The entity type to get the count for</typeparam>
-        /// <param name="filter">f => f.Eq(x => x.Prop, Value) &amp; f.Gt(x => x.Prop, Value)</param>
-        /// <param name="cancellation">An optional cancellation token</param>
-        /// <param name="options">An optional CountOptions object</param>
-        public static Task<long> CountAsync<T>(Func<FilterDefinitionBuilder<T>, FilterDefinition<T>> filter, CancellationToken cancellation = default, CountOptions? options = null) where T : IEntity
-        {
-            return Context.CountAsync(filter, cancellation, options);
-        }
-
-        /// <summary>
-        /// Gets an accurate count of how many total entities are in the collection for a given entity type
-        /// </summary>
-        /// <typeparam name="T">The entity type to get the count for</typeparam>
-        /// <param name="cancellation">An optional cancellation token</param>
-        public static Task<long> CountAsync<T>(CancellationToken cancellation = default) where T : IEntity
-        {
-            return Context.CountAsync<T>(cancellation);
-        }
-    }
-}
diff --git a/MongoDB.Entities/DB/DB.Delete.cs b/MongoDB.Entities/DB/DB.Delete.cs
deleted file mode 100644
index 98b085483..000000000
--- a/MongoDB.Entities/DB/DB.Delete.cs
+++ /dev/null
@@ -1,81 +0,0 @@
-using MongoDB.Driver;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Linq.Expressions;
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace MongoDB.Entities
-{
-    public static partial class DB
-    {
-
-        /// <summary>
-        /// Deletes a single entity from MongoDB.
-        /// <para>HINT: If this entity is referenced by one-to-many/many-to-many relationships, those references are also deleted.</para>
-        /// </summary>
-        /// <typeparam name="T">Any class that implements IEntity</typeparam>
-        /// <param name="ID">The Id of the entity to delete</param>
-        /// <param name="cancellation">An optional cancellation token</param>
-        public static Task<DeleteResult> DeleteAsync<T>(string ID, CancellationToken cancellation = default) where T : IEntity
-        {
-            return Context.DeleteAsync<T>(ID, cancellation);
-        }
-
-        /// <summary>
-        /// Deletes entities using a collection of IDs
-        /// <para>HINT: If more than 100,000 IDs are passed in, they will be processed in batches of 100k.</para>
-        /// <para>HINT: If these entities are referenced by one-to-many/many-to-many relationships, those references are also deleted.</para>
-        /// </summary>
-        /// <typeparam name="T">Any class that implements IEntity</typeparam>
-        /// <param name="IDs">An IEnumerable of entity IDs</param>
-        /// <param name="cancellation">An optional cancellation token</param>
-        public static Task<DeleteResult> DeleteAsync<T>(IEnumerable<string> IDs, CancellationToken cancellation = default) where T : IEntity
-        {
-            return Context.DeleteAsync<T>(IDs, cancellation);
-        }
-
-        /// <summary>
-        /// Deletes matching entities with an expression
-        /// <para>HINT: If the expression matches more than 100,000 entities, they will be deleted in batches of 100k.</para>
-        /// <para>HINT: If these entities are referenced by one-to-many/many-to-many relationships, those references are also deleted.</para>
-        /// </summary>
-        /// <typeparam name="T">Any class that implements IEntity</typeparam>
-        /// <param name="expression">A lambda expression for matching entities to delete.</param>
-        /// <param name="cancellation">An optional cancellation token</param>
-        /// <param name="collation">An optional collation object</param>
-        public static Task<DeleteResult> DeleteAsync<T>(Expression<Func<T, bool>> expression, CancellationToken cancellation = default, Collation? collation = null) where T : IEntity
-        {
-            return Context.DeleteAsync(expression, collation: collation, cancellation: cancellation);
-        }
-
-        /// <summary>
-        /// Deletes matching entities with a filter expression
-        /// <para>HINT: If the expression matches more than 100,000 entities, they will be deleted in batches of 100k.</para>
-        /// <para>HINT: If these entities are referenced by one-to-many/many-to-many relationships, those references are also deleted.</para>
-        /// </summary>
-        /// <typeparam name="T">Any class that implements IEntity</typeparam>
-        /// <param name="filter">f => f.Eq(x => x.Prop, Value) &amp; f.Gt(x => x.Prop, Value)</param>
-        /// <param name="cancellation">An optional cancellation token</param>
-        /// <param name="collation">An optional collation object</param>
-        public static Task<DeleteResult> DeleteAsync<T>(Func<FilterDefinitionBuilder<T>, FilterDefinition<T>> filter, CancellationToken cancellation = default, Collation? collation = null) where T : IEntity
-        {
-            return Context.DeleteAsync(filter, collation: collation, cancellation: cancellation);
-        }
-
-        /// <summary>
-        /// Deletes matching entities with a filter definition
-        /// <para>HINT: If the expression matches more than 100,000 entities, they will be deleted in batches of 100k.</para>
-        /// <para>HINT: If these entities are referenced by one-to-many/many-to-many relationships, those references are also deleted.</para>
-        /// </summary>
-        /// <typeparam name="T">Any class that implements IEntity</typeparam>
-        /// <param name="filter">A filter definition for matching entities to delete.</param>
-        /// <param name="cancellation">An optional cancellation token</param>
-        /// <param name="collation">An optional collation object</param>
-        public static Task<DeleteResult> DeleteAsync<T>(FilterDefinition<T> filter, CancellationToken cancellation = default, Collation? collation = null) where T : IEntity
-        {
-            return Context.DeleteAsync(filter, collation: collation, cancellation: cancellation);
-        }
-    }
-}
diff --git a/MongoDB.Entities/DB/DB.Distinct.cs b/MongoDB.Entities/DB/DB.Distinct.cs
deleted file mode 100644
index b5170053f..000000000
--- a/MongoDB.Entities/DB/DB.Distinct.cs
+++ /dev/null
@@ -1,16 +0,0 @@
-using MongoDB.Driver;
-
-namespace MongoDB.Entities
-{
-    public static partial class DB
-    {
-        /// <summary>
-        /// Represents a MongoDB Distinct command where you can get back distinct values for a given property of a given Entity.
-        /// </summary>
-        /// <typeparam name="T">Any Entity that implements IEntity interface</typeparam>
-        /// <typeparam name="TProperty">The type of the property of the entity you'd like to get unique values for</typeparam>
-        /// <param name="collectionName">Specifiy to override the collection name</param>
-        public static Distinct<T, TProperty> Distinct<T, TProperty>(string? collectionName = null) where T : IEntity
-            => new(Context, Collection<T>(collectionName));
-    }
-}
diff --git a/MongoDB.Entities/DB/DB.File.cs b/MongoDB.Entities/DB/DB.File.cs
deleted file mode 100644
index 0aef3d0b9..000000000
--- a/MongoDB.Entities/DB/DB.File.cs
+++ /dev/null
@@ -1,18 +0,0 @@
-using MongoDB.Bson;
-using System;
-
-namespace MongoDB.Entities
-{
-    public static partial class DB
-    {
-        /// <summary>
-        /// Returns a DataStreamer object to enable uploading/downloading file data directly by supplying the ID of the file entity
-        /// </summary>
-        /// <typeparam name="T">The file entity type</typeparam>
-        /// <param name="ID">The ID of the file entity</param>        
-        public static DataStreamer<T> File<T>(string ID) where T : FileEntity, new()
-        {
-            return Context.File<T>(ID);
-        }
-    }
-}
diff --git a/MongoDB.Entities/DB/DB.Find.cs b/MongoDB.Entities/DB/DB.Find.cs
deleted file mode 100644
index 02fda51c7..000000000
--- a/MongoDB.Entities/DB/DB.Find.cs
+++ /dev/null
@@ -1,24 +0,0 @@
-using MongoDB.Driver;
-
-namespace MongoDB.Entities
-{
-    public static partial class DB
-    {
-        /// <summary>
-        /// Represents a MongoDB Find command
-        /// <para>TIP: Specify your criteria using .Match() .Sort() .Skip() .Take() .Project() .Option() methods and finally call .Execute()</para>
-        /// </summary>
-        /// <typeparam name="T">Any class that implements IEntity</typeparam>
-        public static Find<T> Find<T>(string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
-            => new(Context, collection ?? Collection<T>(collectionName));
-
-        /// <summary>
-        /// Represents a MongoDB Find command
-        /// <para>TIP: Specify your criteria using .Match() .Sort() .Skip() .Take() .Project() .Option() methods and finally call .Execute()</para>
-        /// </summary>
-        /// <typeparam name="T">Any class that implements IEntity</typeparam>
-        /// <typeparam name="TProjection">The type that is returned by projection</typeparam>
-        public static Find<T, TProjection> Find<T, TProjection>(string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
-            => new(Context, collection ?? Collection<T>(collectionName));
-    }
-}
diff --git a/MongoDB.Entities/DB/DB.Fluent.cs b/MongoDB.Entities/DB/DB.Fluent.cs
deleted file mode 100644
index 1cd48f3ad..000000000
--- a/MongoDB.Entities/DB/DB.Fluent.cs
+++ /dev/null
@@ -1,32 +0,0 @@
-using MongoDB.Driver;
-
-namespace MongoDB.Entities
-{
-    public static partial class DB
-    {
-        /// <summary>
-        /// Exposes the MongoDB collection for the given IEntity as an IAggregateFluent in order to facilitate Fluent queries.
-        /// </summary>
-        /// <typeparam name="T">Any class that implements IEntity</typeparam>
-        /// <param name="options">The options for the aggregation. This is not required.</param>
-        public static IAggregateFluent<T> Fluent<T>(AggregateOptions? options = null) where T : IEntity
-        {
-            return Context.Fluent<T>(options);
-        }
-
-        /// <summary>
-        /// Start a fluent aggregation pipeline with a $text stage with the supplied parameters.
-        /// <para>TIP: Make sure to define a text index with DB.Index&lt;T&gt;() before searching</para>
-        /// </summary>
-        /// <param name="searchType">The type of text matching to do</param>
-        /// <param name="searchTerm">The search term</param>
-        /// <param name="caseSensitive">Case sensitivity of the search (optional)</param>
-        /// <param name="diacriticSensitive">Diacritic sensitivity of the search (optional)</param>
-        /// <param name="language">The language for the search (optional)</param>
-        /// <param name="options">Options for finding documents (not required)</param>
-        public static IAggregateFluent<T> FluentTextSearch<T>(Search searchType, string searchTerm, bool caseSensitive = false, bool diacriticSensitive = false, string? language = null, AggregateOptions? options = null) where T : IEntity
-        {
-            return Context.FluentTextSearch<T>(searchType: searchType, searchTerm: searchTerm, caseSensitive: caseSensitive, diacriticSensitive: diacriticSensitive, language: language, options: options);
-        }
-    }
-}
diff --git a/MongoDB.Entities/DB/DB.GeoNear.cs b/MongoDB.Entities/DB/DB.GeoNear.cs
deleted file mode 100644
index 7f51fd763..000000000
--- a/MongoDB.Entities/DB/DB.GeoNear.cs
+++ /dev/null
@@ -1,29 +0,0 @@
-using MongoDB.Bson;
-using MongoDB.Driver;
-using System;
-using System.Linq.Expressions;
-
-namespace MongoDB.Entities
-{
-    public static partial class DB
-    {
-        /// <summary>
-        /// Start a fluent aggregation pipeline with a $GeoNear stage with the supplied parameters.
-        /// </summary>
-        /// <param name="NearCoordinates">The coordinates from which to find documents from</param>
-        /// <param name="DistanceField">x => x.Distance</param>
-        /// <param name="Spherical">Calculate distances using spherical geometry or not</param>
-        /// <param name="MaxDistance">The maximum distance in meters from the center point that the documents can be</param>
-        /// <param name="MinDistance">The minimum distance in meters from the center point that the documents can be</param>
-        /// <param name="Limit">The maximum number of documents to return</param>
-        /// <param name="Query">Limits the results to the documents that match the query</param>
-        /// <param name="DistanceMultiplier">The factor to multiply all distances returned by the query</param>
-        /// <param name="IncludeLocations">Specify the output field to store the point used to calculate the distance</param>
-        /// <param name="IndexKey"></param>
-        /// <param name="options">The options for the aggregation. This is not required.</param>
-        public static IAggregateFluent<T> FluentGeoNear<T>(Coordinates2D NearCoordinates, Expression<Func<T, object>>? DistanceField, bool Spherical = true, double? MaxDistance = null, double? MinDistance = null, int? Limit = null, BsonDocument? Query = null, double? DistanceMultiplier = null, Expression<Func<T, object>>? IncludeLocations = null, string? IndexKey = null, AggregateOptions? options = null) where T : IEntity
-        {
-            return Context.GeoNear<T>(NearCoordinates: NearCoordinates, DistanceField: DistanceField, Spherical: Spherical, MaxDistance: MaxDistance, MinDistance: MinDistance, Limit: Limit, Query: Query, DistanceMultiplier: DistanceMultiplier, IncludeLocations: IncludeLocations, IndexKey: IndexKey, options: options);
-        }
-    }
-}
diff --git a/MongoDB.Entities/DB/DB.Index.cs b/MongoDB.Entities/DB/DB.Index.cs
deleted file mode 100644
index 1598df601..000000000
--- a/MongoDB.Entities/DB/DB.Index.cs
+++ /dev/null
@@ -1,17 +0,0 @@
-using MongoDB.Driver;
-
-namespace MongoDB.Entities
-{
-    public static partial class DB
-    {
-        /// <summary>
-        /// Represents an index for a given IEntity
-        /// <para>TIP: Define the keys first with .Key() method and finally call the .Create() method.</para>
-        /// </summary>
-        /// <typeparam name="T">Any class that implements IEntity</typeparam>
-        public static Index<T> Index<T>(string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
-        {
-            return new Index<T>(Context, collection ?? Collection<T>(collectionName));
-        }
-    }
-}
diff --git a/MongoDB.Entities/DB/DB.Insert.cs b/MongoDB.Entities/DB/DB.Insert.cs
deleted file mode 100644
index 024fbf410..000000000
--- a/MongoDB.Entities/DB/DB.Insert.cs
+++ /dev/null
@@ -1,36 +0,0 @@
-using MongoDB.Driver;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace MongoDB.Entities
-{
-    public static partial class DB
-    {
-
-        /// <summary>
-        /// Inserts a new entity into the colleciton.
-        /// </summary>
-        /// <typeparam name="T">Any class that implements IEntity</typeparam>
-        /// <param name="entity">The instance to persist</param>
-        /// <param name="cancellation">And optional cancellation token</param>
-        public static Task InsertAsync<T>(T entity, CancellationToken cancellation = default) where T : IEntity
-        {
-            return Context.InsertAsync(entity, cancellation);
-        }
-
-        /// <summary>
-        /// Inserts a batch of new entities into the collection.
-        /// </summary>
-        /// <typeparam name="T">Any class that implements IEntity</typeparam>
-        /// <param name="entities">The entities to persist</param>
-        /// <param name="session">An optional session if using within a transaction</param>
-        /// <param name="cancellation">And optional cancellation token</param>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static Task<BulkWriteResult<T>> InsertAsync<T>(IEnumerable<T> entities, CancellationToken cancellation = default) where T : IEntity
-        {
-            return Context.InsertAsync(entities, cancellation);
-        }
-    }
-}
diff --git a/MongoDB.Entities/DB/DB.Migrate.cs b/MongoDB.Entities/DB/DB.Migrate.cs
index 021e8d188..7672be7c6 100644
--- a/MongoDB.Entities/DB/DB.Migrate.cs
+++ b/MongoDB.Entities/DB/DB.Migrate.cs
@@ -13,10 +13,9 @@ public static partial class DB
         /// Discover and run migrations from the same assembly as the specified type.
         /// </summary>
         /// <typeparam name="T">A type that is from the same assembly as the migrations you want to run</typeparam>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static Task MigrateAsync<T>(string tenantPrefix = null) where T : class
+        public static Task MigrateAsync<T>() where T : class
         {
-            return Migrate(typeof(T), tenantPrefix);
+            return Migrate(typeof(T));
         }
 
         /// <summary>
@@ -25,23 +24,21 @@ public static Task MigrateAsync<T>(string tenantPrefix = null) where T : class
         /// and implement IMigration interface on them. 
         /// Call this method at the startup of the application in order to run the migrations.</para>
         /// </summary>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static Task MigrateAsync(string tenantPrefix = null)
+        public static Task MigrateAsync()
         {
-            return Migrate(null, tenantPrefix);
+            return Migrate(null);
         }
 
         /// <summary>
         /// Executes the given collection of IMigrations in the correct order to transform the database.
         /// </summary>
         /// <param name="migrations">The collection of migrations to execute</param>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static Task MigrationsAsync(IEnumerable<IMigration> migrations, string tenantPrefix = null)
+        public static Task MigrationsAsync(IEnumerable<IMigration> migrations)
         {
-            return Execute(migrations, tenantPrefix);
+            return Execute(migrations);
         }
 
-        private static Task Migrate(Type targetType, string tenantPrefix = null)
+        private static Task Migrate(Type? targetType)
         {
             IEnumerable<Assembly> assemblies;
 
@@ -77,13 +74,13 @@ private static Task Migrate(Type targetType, string tenantPrefix = null)
             if (!types.Any())
                 throw new InvalidOperationException("Didn't find any classes that implement IMigrate interface.");
 
-            return Execute(types.Select(t => (IMigration)Activator.CreateInstance(t)), tenantPrefix);
+            return Execute(types.Select(t => (IMigration)Activator.CreateInstance(t)));
         }
 
-        private static async Task Execute(IEnumerable<IMigration> migrations, string tenantPrefix = null)
+        private static async Task Execute(IEnumerable<IMigration> migrations)
         {
             var lastMigNum = await
-                Find<Migration, int>(tenantPrefix: tenantPrefix)
+               Context.Find<Migration, int>()
                 .Sort(m => m.Number, Order.Descending)
                 .Project(m => m.Number)
                 .ExecuteFirstAsync()
@@ -119,7 +116,7 @@ private static async Task Execute(IEnumerable<IMigration> migrations, string ten
                     Name = migration.Value.name,
                     TimeTakenSeconds = sw.Elapsed.TotalSeconds
                 };
-                await SaveAsync(mig, tenantPrefix: tenantPrefix).ConfigureAwait(false);
+                await Context.SaveAsync<Migration, string>(mig).ConfigureAwait(false);
                 sw.Stop();
                 sw.Reset();
             }
diff --git a/MongoDB.Entities/DB/DB.PagedSearch.cs b/MongoDB.Entities/DB/DB.PagedSearch.cs
deleted file mode 100644
index a1697f34e..000000000
--- a/MongoDB.Entities/DB/DB.PagedSearch.cs
+++ /dev/null
@@ -1,26 +0,0 @@
-using MongoDB.Driver;
-
-namespace MongoDB.Entities
-{
-    public static partial class DB
-    {
-        /// <summary>
-        /// Represents an aggregation query that retrieves results with easy paging support.
-        /// </summary>
-        /// <typeparam name="T">Any class that implements IEntity</typeparam>
-        /// <param name="session">An optional session if using within a transaction</param>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static PagedSearch<T> PagedSearch<T>(IClientSessionHandle session = null, string tenantPrefix = null) where T : IEntity
-            => new(session, null, tenantPrefix);
-
-        /// <summary>
-        /// Represents an aggregation query that retrieves results with easy paging support.
-        /// </summary>
-        /// <typeparam name="T">Any class that implements IEntity</typeparam>
-        /// <param name="session">An optional session if using within a transaction</param>
-        /// <typeparam name="TProjection">The type you'd like to project the results to.</typeparam>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static PagedSearch<T, TProjection> PagedSearch<T, TProjection>(IClientSessionHandle session = null, string tenantPrefix = null) where T : IEntity
-            => new(session, null, tenantPrefix);
-    }
-}
diff --git a/MongoDB.Entities/DB/DB.Pipeline.cs b/MongoDB.Entities/DB/DB.Pipeline.cs
deleted file mode 100644
index cf6d94fab..000000000
--- a/MongoDB.Entities/DB/DB.Pipeline.cs
+++ /dev/null
@@ -1,67 +0,0 @@
-using MongoDB.Driver;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace MongoDB.Entities
-{
-    public static partial class DB
-    {
-        /// <summary>
-        /// Executes an aggregation pipeline by supplying a 'Template' object and returns a cursor
-        /// </summary>
-        /// <typeparam name="T">Any class that implements IEntity</typeparam>
-        /// <typeparam name="TResult">The type of the resulting objects</typeparam>
-        /// <param name="template">A 'Template' object with tags replaced</param>
-        /// <param name="options">The options for the aggregation. This is not required.</param>
-        /// <param name="session">An optional session if using within a transaction</param>
-        /// <param name="cancellation">An optional cancellation token</param>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static Task<IAsyncCursor<TResult>> PipelineCursorAsync<T, TResult>(Template<T, TResult> template, AggregateOptions? options = null, CancellationToken cancellation = default) where T : IEntity
-        {
-            return Context.PipelineCursorAsync(template, options, cancellation);
-        }
-
-        /// <summary>
-        /// Executes an aggregation pipeline by supplying a 'Template' object and get a list of results
-        /// </summary>
-        /// <typeparam name="T">Any class that implements IEntity</typeparam>
-        /// <typeparam name="TResult">The type of the resulting objects</typeparam>
-        /// <param name="template">A 'Template' object with tags replaced</param>
-        /// <param name="options">The options for the aggregation. This is not required.</param>
-        /// <param name="cancellation">An optional cancellation token</param>
-        public static Task<List<TResult>> PipelineAsync<T, TResult>(Template<T, TResult> template, AggregateOptions? options = null, CancellationToken cancellation = default) where T : IEntity
-        {
-            return Context.PipelineAsync(template, options, cancellation);
-        }
-
-        /// <summary>
-        /// Executes an aggregation pipeline by supplying a 'Template' object and get a single result or default value if not found. 
-        /// If more than one entity is found, it will throw an exception.
-        /// </summary>
-        /// <typeparam name="T">Any class that implements IEntity</typeparam>
-        /// <typeparam name="TResult">The type of the resulting object</typeparam>
-        /// <param name="template">A 'Template' object with tags replaced</param>
-        /// <param name="options">The options for the aggregation. This is not required.</param>
-        /// <param name="cancellation">An optional cancellation token</param>
-        public static Task<TResult> PipelineSingleAsync<T, TResult>(Template<T, TResult> template, AggregateOptions? options = null, CancellationToken cancellation = default) where T : IEntity
-        {
-            return Context.PipelineSingleAsync(template, options, cancellation);
-        }
-
-        /// <summary>
-        /// Executes an aggregation pipeline by supplying a 'Template' object and get the first result or default value if not found.
-        /// </summary>
-        /// <typeparam name="T">Any class that implements IEntity</typeparam>
-        /// <typeparam name="TResult">The type of the resulting object</typeparam>
-        /// <param name="template">A 'Template' object with tags replaced</param>
-        /// <param name="options">The options for the aggregation. This is not required.</param>
-        /// <param name="cancellation">An optional cancellation token</param>
-        public static Task<TResult> PipelineFirstAsync<T, TResult>(Template<T, TResult> template, AggregateOptions? options = null, CancellationToken cancellation = default) where T : IEntity
-        {
-            return Context.PipelineFirstAsync(template, options, cancellation);
-
-        }
-    }
-}
diff --git a/MongoDB.Entities/DB/DB.Queryable.cs b/MongoDB.Entities/DB/DB.Queryable.cs
deleted file mode 100644
index f75126adf..000000000
--- a/MongoDB.Entities/DB/DB.Queryable.cs
+++ /dev/null
@@ -1,18 +0,0 @@
-using MongoDB.Driver;
-using MongoDB.Driver.Linq;
-
-namespace MongoDB.Entities
-{
-    public static partial class DB
-    {
-        /// <summary>
-        /// Exposes the MongoDB collection for the given IEntity as an IQueryable in order to facilitate LINQ queries.
-        /// </summary>
-        /// <param name="options">The aggregate options</param>
-        /// <typeparam name="T">Any class that implements IEntity</typeparam>
-        public static IMongoQueryable<T> Queryable<T>(AggregateOptions? options = null) where T : IEntity
-        {
-            return Context.Queryable<T>(options);
-        }
-    }
-}
diff --git a/MongoDB.Entities/DB/DB.Replace.cs b/MongoDB.Entities/DB/DB.Replace.cs
deleted file mode 100644
index debec4caa..000000000
--- a/MongoDB.Entities/DB/DB.Replace.cs
+++ /dev/null
@@ -1,17 +0,0 @@
-using MongoDB.Driver;
-
-namespace MongoDB.Entities
-{
-    public static partial class DB
-    {
-        /// <summary>
-        /// Represents a ReplaceOne command, which can replace the first matched document with a given entity
-        /// <para>TIP: Specify a filter first with the .Match(). Then set entity with .WithEntity() and finally call .Execute() to run the command.</para>
-        /// </summary>
-        /// <typeparam name="T">Any class that implements IEntity</typeparam>
-        /// <param name="session">An optional session if using within a transaction</param>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static Replace<T> Replace<T>(IClientSessionHandle session = null, string tenantPrefix = null) where T : IEntity
-            => new(session, null, null, null, tenantPrefix);
-    }
-}
diff --git a/MongoDB.Entities/DB/DB.Save.cs b/MongoDB.Entities/DB/DB.Save.cs
deleted file mode 100644
index f5a562ec7..000000000
--- a/MongoDB.Entities/DB/DB.Save.cs
+++ /dev/null
@@ -1,114 +0,0 @@
-using MongoDB.Driver;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Linq.Expressions;
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace MongoDB.Entities
-{
-    public static partial class DB
-    {
-
-
-        /// <summary>
-        /// Saves a complete entity replacing an existing entity or creating a new one if it does not exist. 
-        /// If ID value is null, a new entity is created. If ID has a value, then existing entity is replaced.
-        /// </summary>
-        /// <typeparam name="T">Any class that implements IEntity</typeparam>
-        /// <param name="entity">The instance to persist</param>
-        /// <param name="cancellation">And optional cancellation token</param>
-        public static Task SaveAsync<T>(T entity, CancellationToken cancellation = default) where T : IEntity
-        {
-            return Context.SaveAsync<T>(entity, cancellation);
-        }
-
-        /// <summary>
-        /// Saves a batch of complete entities replacing existing ones or creating new ones if they do not exist. 
-        /// If ID value is null, a new entity is created. If ID has a value, then existing entity is replaced.
-        /// </summary>
-        /// <typeparam name="T">Any class that implements IEntity</typeparam>
-        /// <param name="entities">The entities to persist</param>
-        /// <param name="cancellation">And optional cancellation token</param>
-        public static Task<BulkWriteResult<T>> SaveAsync<T>(IEnumerable<T> entities, CancellationToken cancellation = default) where T : IEntity
-        {
-            return Context.SaveAsync(entities, cancellation);
-        }
-
-        /// <summary>
-        /// Saves an entity partially with only the specified subset of properties. 
-        /// If ID value is null, a new entity is created. If ID has a value, then existing entity is updated.
-        /// <para>TIP: The properties to be saved can be specified with a 'New' expression. 
-        /// You can only specify root level properties with the expression.</para>
-        /// </summary>
-        /// <typeparam name="T">Any class that implements IEntity</typeparam>
-        /// <param name="entity">The entity to save</param>
-        /// <param name="members">x => new { x.PropOne, x.PropTwo }</param>
-        /// <param name="cancellation">An optional cancellation token</param>
-        public static Task<UpdateResult> SaveOnlyAsync<T>(T entity, Expression<Func<T, object>> members, CancellationToken cancellation = default) where T : IEntity
-        {
-            return Context.SaveOnlyAsync(entity, members, cancellation);
-
-        }
-
-        /// <summary>
-        /// Saves a batch of entities partially with only the specified subset of properties. 
-        /// If ID value is null, a new entity is created. If ID has a value, then existing entity is updated.
-        /// <para>TIP: The properties to be saved can be specified with a 'New' expression. 
-        /// You can only specify root level properties with the expression.</para>
-        /// </summary>
-        /// <typeparam name="T">Any class that implements IEntity</typeparam>
-        /// <param name="entities">The batch of entities to save</param>
-        /// <param name="members">x => new { x.PropOne, x.PropTwo }</param>
-        /// <param name="cancellation">An optional cancellation token</param>
-        public static Task<BulkWriteResult<T>> SaveOnlyAsync<T>(IEnumerable<T> entities, Expression<Func<T, object>> members, CancellationToken cancellation = default) where T : IEntity
-        {
-            return Context.SaveOnlyAsync(entities, members, cancellation);
-        }
-
-        /// <summary>
-        /// Saves an entity partially excluding the specified subset of properties. 
-        /// If ID value is null, a new entity is created. If ID has a value, then existing entity is updated.
-        /// <para>TIP: The properties to be excluded can be specified with a 'New' expression. 
-        /// You can only specify root level properties with the expression.</para>
-        /// </summary>
-        /// <typeparam name="T">Any class that implements IEntity</typeparam>
-        /// <param name="entity">The entity to save</param>
-        /// <param name="members">x => new { x.PropOne, x.PropTwo }</param>
-        /// <param name="cancellation">An optional cancellation token</param>
-        public static Task<UpdateResult> SaveExceptAsync<T>(T entity, Expression<Func<T, object>> members, CancellationToken cancellation = default) where T : IEntity
-        {
-            return Context.SaveExceptAsync(entity, members, cancellation);
-        }
-
-        /// <summary>
-        /// Saves a batch of entities partially excluding the specified subset of properties. 
-        /// If ID value is null, a new entity is created. If ID has a value, then existing entity is updated.
-        /// <para>TIP: The properties to be excluded can be specified with a 'New' expression. 
-        /// You can only specify root level properties with the expression.</para>
-        /// </summary>
-        /// <typeparam name="T">Any class that implements IEntity</typeparam>
-        /// <param name="entities">The batch of entities to save</param>
-        /// <param name="members">x => new { x.PropOne, x.PropTwo }</param>
-        /// <param name="cancellation">An optional cancellation token</param>
-        public static Task<BulkWriteResult<T>> SaveExceptAsync<T>(IEnumerable<T> entities, Expression<Func<T, object>> members, CancellationToken cancellation = default) where T : IEntity
-        {
-            return Context.SaveExceptAsync(entities, members, cancellation);
-        }
-
-        /// <summary>
-        /// Saves an entity partially while excluding some properties. 
-        /// The properties to be excluded can be specified using the [Preserve] or [DontPreserve] attributes.
-        /// </summary>
-        /// <typeparam name="T">Any class that implements IEntity</typeparam>
-        /// <param name="entity">The entity to save</param>
-        /// <param name="cancellation">An optional cancellation token</param>
-        public static Task<UpdateResult> SavePreservingAsync<T>(T entity, CancellationToken cancellation = default) where T : IEntity
-        {
-            return Context.SavePreservingAsync(entity, cancellation);
-        }
-
-
-    }
-}
diff --git a/MongoDB.Entities/DB/DB.Sequence.cs b/MongoDB.Entities/DB/DB.Sequence.cs
deleted file mode 100644
index 05bd537bb..000000000
--- a/MongoDB.Entities/DB/DB.Sequence.cs
+++ /dev/null
@@ -1,30 +0,0 @@
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace MongoDB.Entities
-{
-    public static partial class DB
-    {
-        //NOTE: transaction support will not be added due to unpredictability with concurrency.
-
-        /// <summary>
-        /// Returns an atomically generated sequential number for the given Entity type everytime the method is called
-        /// </summary>
-        /// <typeparam name="T">The type of entity to get the next sequential number for</typeparam>
-        /// <param name="cancellation">An optional cancellation token</param>
-        public static Task<ulong> NextSequentialNumberAsync<T>(CancellationToken cancellation = default) where T : IEntity
-        {
-            return Context.NextSequentialNumberAsync<T>(cancellation);
-        }
-
-        /// <summary>
-        /// Returns an atomically generated sequential number for the given sequence name everytime the method is called
-        /// </summary>
-        /// <param name="sequenceName">The name of the sequence to get the next number for</param>
-        /// <param name="cancellation">An optional cancellation token</param>
-        public static Task<ulong> NextSequentialNumberAsync(string sequenceName, CancellationToken cancellation = default)
-        {
-            return Context.NextSequentialNumberAsync(sequenceName, cancellation);
-        }
-    }
-}
diff --git a/MongoDB.Entities/DB/DB.Transaction.cs b/MongoDB.Entities/DB/DB.Transaction.cs
deleted file mode 100644
index 0d746e449..000000000
--- a/MongoDB.Entities/DB/DB.Transaction.cs
+++ /dev/null
@@ -1,30 +0,0 @@
-using MongoDB.Driver;
-
-namespace MongoDB.Entities
-{
-    public static partial class DB
-    {
-        /// <summary>
-        /// Gets a transaction context/scope for a given database or the default database if not specified.
-        /// </summary>
-        /// <param name="database">The name of the database which this transaction is for (not required)</param>
-        /// <param name="options">Client session options (not required)</param>
-        /// <param name="modifiedBy"></param>
-        public static Transaction Transaction(string database = default, ClientSessionOptions options = null, ModifiedBy modifiedBy = null)
-        {
-            return new Transaction(database, options, modifiedBy);
-        }
-
-        /// <summary>
-        /// Gets a transaction context/scope for a given entity type's database
-        /// </summary>
-        /// <typeparam name="T">The entity type to determine the database from for the transaction</typeparam>
-        /// <param name="options">Client session options (not required)</param>
-        /// <param name="modifiedBy"></param>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static Transaction Transaction<T>(ClientSessionOptions options = null, ModifiedBy modifiedBy = null, string tenantPrefix = null) where T : IEntity
-        {
-            return new Transaction(DatabaseName<T>(tenantPrefix), options, modifiedBy);
-        }
-    }
-}
diff --git a/MongoDB.Entities/DB/DB.Update.cs b/MongoDB.Entities/DB/DB.Update.cs
deleted file mode 100644
index 06570c5fe..000000000
--- a/MongoDB.Entities/DB/DB.Update.cs
+++ /dev/null
@@ -1,32 +0,0 @@
-using MongoDB.Driver;
-
-namespace MongoDB.Entities
-{
-    public static partial class DB
-    {
-        /// <summary>
-        /// Represents an update command
-        /// <para>TIP: Specify a filter first with the .Match() method. Then set property values with .Modify() and finally call .Execute() to run the command.</para>
-        /// </summary>
-        /// <typeparam name="T">Any class that implements IEntity</typeparam>
-        public static Update<T> Update<T>() where T : IEntity
-            => Context.Update<T>();
-
-        /// <summary>
-        /// Update and retrieve the first document that was updated.
-        /// <para>TIP: Specify a filter first with the .Match(). Then set property values with .Modify() and finally call .Execute() to run the command.</para>
-        /// </summary>
-        /// <typeparam name="T">Any class that implements IEntity</typeparam>
-        /// <typeparam name="TProjection">The type to project to</typeparam>
-        public static UpdateAndGet<T, TProjection> UpdateAndGet<T, TProjection>() where T : IEntity
-            => Context.UpdateAndGet<T, TProjection>();
-
-        /// <summary>
-        /// Update and retrieve the first document that was updated.
-        /// <para>TIP: Specify a filter first with the .Match(). Then set property values with .Modify() and finally call .Execute() to run the command.</para>
-        /// </summary>
-        /// <typeparam name="T">Any class that implements IEntity</typeparam>
-        public static UpdateAndGet<T> UpdateAndGet<T>() where T : IEntity
-            => Context.UpdateAndGet<T>();
-    }
-}
diff --git a/MongoDB.Entities/DB/DB.Watcher.cs b/MongoDB.Entities/DB/DB.Watcher.cs
deleted file mode 100644
index 0776c751a..000000000
--- a/MongoDB.Entities/DB/DB.Watcher.cs
+++ /dev/null
@@ -1,25 +0,0 @@
-using System.Collections.Generic;
-
-namespace MongoDB.Entities
-{
-    public static partial class DB
-    {
-        /// <summary>
-        /// Retrieves the 'change-stream' watcher instance for a given unique name. 
-        /// If an instance for the name does not exist, it will return a new instance. 
-        /// If an instance already exists, that instance will be returned.
-        /// </summary>
-        /// <typeparam name="T">The entity type to get a watcher for</typeparam>
-        /// <param name="name">A unique name for the watcher of this entity type. Names can be duplicate among different entity types.</param>
-        public static Watcher<T> Watcher<T>(string name) where T : IEntity
-        {
-            return Context.Watcher<T>(name);
-        }
-
-        /// <summary>
-        /// Returns all the watchers for a given entity type
-        /// </summary>
-        /// <typeparam name="T">The entity type to get the watcher of</typeparam>
-        public static IEnumerable<Watcher<T>> Watchers<T>() where T : IEntity => Context.Cache<T>().Watchers.Values;
-    }
-}

From e1aba55d87f3d58f97c5dd4bfa13f6907703e0cc Mon Sep 17 00:00:00 2001
From: Ahmed Fwela <ahmednfwela@bdaya-dev.com>
Date: Tue, 28 Dec 2021 06:25:59 +0200
Subject: [PATCH 25/26] WIP

---
 Benchmark/Benchmarks/Update.cs                | 11 +++--
 .../Builders/FilterQuery.Extensions.cs        | 43 ++++++++++++-------
 .../Builders/FilterQuery.Interface.cs         |  5 +++
 MongoDB.Entities/Builders/FilterQuery.cs      |  2 +
 MongoDB.Entities/Builders/Find.cs             |  6 +--
 MongoDB.Entities/Builders/Update.cs           |  2 +-
 MongoDB.Entities/DBContext/DBContext.Index.cs | 10 ++---
 .../DBContext/DBContext.Replace.cs            | 12 +++++-
 MongoDB.Entities/DBContext/DBContext.Save.cs  | 16 ++++++-
 .../DBContext/DBContext.Update.cs             | 12 +++++-
 MongoDB.Entities/Relationships/NewMany.cs     |  2 +-
 11 files changed, 85 insertions(+), 36 deletions(-)

diff --git a/Benchmark/Benchmarks/Update.cs b/Benchmark/Benchmarks/Update.cs
index 5dedb32f8..a65cd9aa9 100644
--- a/Benchmark/Benchmarks/Update.cs
+++ b/Benchmark/Benchmarks/Update.cs
@@ -15,13 +15,15 @@ public class UpdateOne : BenchBase
 
         public UpdateOne()
         {
-            DB.SaveAsync(new Author { ID = id, FirstName = "initial" }).GetAwaiter().GetResult();
+            DB.Context.SaveAsync(new Author { ID = id, FirstName = "initial" }).GetAwaiter().GetResult();
         }
 
         [Benchmark]
         public override Task MongoDB_Entities()
         {
-            return DB.Update<Author>()
+            var update = DB.Context.Update<Author>();
+            update.MatchID(id);
+            return DB.Context.Update<Author>()
                      .MatchID(id)
                      .Modify(a => a.FirstName, "updated")
                      .ExecuteAsync();
@@ -44,7 +46,8 @@ public class Update100 : BenchBase
 
         public Update100()
         {
-            DB.Index<Author>()
+            DB.Context
+                .Index<Author>()
               .Key(a => a.FirstName, KeyType.Ascending)
               .Option(o => o.Background = false)
               .CreateAsync()
@@ -64,7 +67,7 @@ public Update100()
         [Benchmark]
         public override Task MongoDB_Entities()
         {
-            return DB
+            return DB.Context
                 .Update<Author>()
                 .Match(x => x.FirstName == guid)
                 .Modify(x => x.FirstName, "updated")
diff --git a/MongoDB.Entities/Builders/FilterQuery.Extensions.cs b/MongoDB.Entities/Builders/FilterQuery.Extensions.cs
index b2be6b40b..2c2b0622f 100644
--- a/MongoDB.Entities/Builders/FilterQuery.Extensions.cs
+++ b/MongoDB.Entities/Builders/FilterQuery.Extensions.cs
@@ -1,41 +1,54 @@
 namespace MongoDB.Entities;
 
+//i dream to live in a world where c# can infer generic arguments on its own
 public static class FilterExt
 {
-    //protected FilterDefinition<T> MergedFilter => Logic.MergeWithGlobalFilter(_ignoreGlobalFilters, _globalFilters, _filter);
+
     /// <summary>
     /// Specify an IEntity ID as the matching criteria
     /// </summary>
     /// <param name="self">the query</param>
-    internal static FilterDefinition<TEntity> MergedFilter<TEntity, TSelf>(this TSelf self)
+    /// <param name="id">A unique IEntity ID</param>
+    public static TSelf MatchID<TEntity, TId, TSelf>(this IFilterBuilder<TEntity, TSelf> self, TId id)
+        where TId : IComparable<TId>, IEquatable<TId>
+        where TEntity : IEntity<TId>
         where TSelf : IFilterBuilder<TEntity, TSelf>
-    {
-        return Logic.MergeWithGlobalFilter(self.IsIgnoreGlobalFilters, self.GlobalFilters, self.Filter);
-    }
+        => self.Match(f => f.Eq(t => t.ID, id));
+
 
     /// <summary>
     /// Specify an IEntity ID as the matching criteria
     /// </summary>
     /// <param name="self">the query</param>
     /// <param name="id">A unique IEntity ID</param>
-    public static TSelf MatchID<TEntity, TId, TSelf>(this TSelf self, TId id)
-        where TId : IComparable<TId>, IEquatable<TId>
-        where TEntity : IEntity<TId>
+    public static TSelf MatchID<TEntity, TSelf>(this IFilterBuilder<TEntity, TSelf> self, string id)
+        where TEntity : IEntity
         where TSelf : IFilterBuilder<TEntity, TSelf>
-    {
-        return self.Match(f => f.Eq(t => t.ID, id));
-    }
+    => MatchID<TEntity, string, TSelf>(self, id);
+
+
+
+
 
     /// <summary>
     /// Specify an IEntity ID as the matching criteria
     /// </summary>
     /// <param name="self">the query</param>
     /// <param name="id">A unique IEntity ID</param>
-    public static TSelf Match<TEntity, TId, TSelf>(this TSelf self, TId id)
+    public static TSelf Match<TEntity, TId, TSelf>(this IFilterBuilder<TEntity, TSelf> self, TId id)
         where TId : IComparable<TId>, IEquatable<TId>
         where TEntity : IEntity<TId>
         where TSelf : IFilterBuilder<TEntity, TSelf>
-    {
-        return self.MatchID<TEntity, TId, TSelf>(id);
-    }
+        => self.MatchID(id);
+
+
+    /// <summary>
+    /// Specify an IEntity ID as the matching criteria
+    /// </summary>
+    /// <param name="self">the query</param>
+    /// <param name="id">A unique IEntity ID</param>
+    public static TSelf Match<TEntity, TSelf>(this IFilterBuilder<TEntity, TSelf> self, string id)
+        where TEntity : IEntity
+        where TSelf : IFilterBuilder<TEntity, TSelf>
+        => self.MatchID(id);
 }
\ No newline at end of file
diff --git a/MongoDB.Entities/Builders/FilterQuery.Interface.cs b/MongoDB.Entities/Builders/FilterQuery.Interface.cs
index ed628ad29..cd389872b 100644
--- a/MongoDB.Entities/Builders/FilterQuery.Interface.cs
+++ b/MongoDB.Entities/Builders/FilterQuery.Interface.cs
@@ -7,6 +7,11 @@ public interface IFilterBuilder<T, TSelf>
     internal FilterDefinition<T> Filter { get; }
     internal Dictionary<Type, (object filterDef, bool prepend)> GlobalFilters { get; }
 
+    internal FilterDefinition<T> MergedFilter => Logic.MergeWithGlobalFilter(IsIgnoreGlobalFilters, GlobalFilters, Filter);
+
+    
+
+
     /// <summary>
     /// Specify that this operation should ignore any global filters
     /// </summary>
diff --git a/MongoDB.Entities/Builders/FilterQuery.cs b/MongoDB.Entities/Builders/FilterQuery.cs
index e99552848..a6c147a8e 100644
--- a/MongoDB.Entities/Builders/FilterQuery.cs
+++ b/MongoDB.Entities/Builders/FilterQuery.cs
@@ -23,9 +23,11 @@ internal FilterQueryBase(Dictionary<Type, (object filterDef, bool prepend)> glob
     bool IFilterBuilder<T, TSelf>.IsIgnoreGlobalFilters => _ignoreGlobalFilters;
     FilterDefinition<T> IFilterBuilder<T, TSelf>.Filter => _filter;
     Dictionary<Type, (object filterDef, bool prepend)> IFilterBuilder<T, TSelf>.GlobalFilters => _globalFilters;
+    internal FilterDefinition<T> MergedFilter => (this as IFilterBuilder<T, TSelf>).MergedFilter;
 
     private TSelf This => (TSelf)this;
 
+
     /// <summary>
     /// Specify that this operation should ignore any global filters
     /// </summary>
diff --git a/MongoDB.Entities/Builders/Find.cs b/MongoDB.Entities/Builders/Find.cs
index 261ee0ccc..64cc6cb9b 100644
--- a/MongoDB.Entities/Builders/Find.cs
+++ b/MongoDB.Entities/Builders/Find.cs
@@ -155,6 +155,7 @@ public async Task<bool> ExecuteAnyAsync(CancellationToken cancellation = default
 
 public static class FindExt
 {
+
     /// <summary>
     /// Find a single IEntity by ID
     /// </summary>
@@ -162,12 +163,11 @@ public static class FindExt
     /// <param name="ID">The unique ID of an IEntity</param>
     /// <param name="cancellation">An optional cancellation token</param>
     /// <returns>A single entity or null if not found</returns>
-    public static Task<TProjection> OneAsync<TEntity, TId, TProjection, TSelf>(this TSelf self, TId ID, CancellationToken cancellation = default)
+    public static Task<TProjection> OneAsync<TEntity, TId, TProjection>(this Find<TEntity, TProjection> self, TId ID, CancellationToken cancellation = default)
         where TId : IComparable<TId>, IEquatable<TId>
         where TEntity : IEntity<TId>
-        where TSelf : Find<TEntity, TProjection>, IFilterBuilder<TEntity, TSelf>
     {
-        self.MatchID<TEntity, TId, TSelf>(ID);
+        self.MatchID(ID);
         return self.ExecuteSingleAsync(cancellation);
     }
 }
diff --git a/MongoDB.Entities/Builders/Update.cs b/MongoDB.Entities/Builders/Update.cs
index e9fb8891e..df85864b7 100644
--- a/MongoDB.Entities/Builders/Update.cs
+++ b/MongoDB.Entities/Builders/Update.cs
@@ -1,6 +1,6 @@
 namespace MongoDB.Entities;
 
-public abstract class UpdateBase<T, TId, TSelf> : FilterQueryBase<T, TId, TSelf>
+public abstract class UpdateBase<T, TId, TSelf> : FilterQueryBase<T, TSelf>
     where TId : IComparable<TId>, IEquatable<TId>
     where T : IEntity<TId>
     where TSelf : UpdateBase<T, TId, TSelf>
diff --git a/MongoDB.Entities/DBContext/DBContext.Index.cs b/MongoDB.Entities/DBContext/DBContext.Index.cs
index dcc8488ae..0ed0f8744 100644
--- a/MongoDB.Entities/DBContext/DBContext.Index.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Index.cs
@@ -8,13 +8,11 @@ public partial class DBContext
         /// Represents an index for a given IEntity
         /// <para>TIP: Define the keys first with .Key() method and finally call the .Create() method.</para>
         /// </summary>
-        /// <typeparam name="T">Any class that implements IEntity</typeparam>
-        /// <typeparam name="TId">ID type</typeparam>
-        public Index<T, TId> Index<T, TId>(string? collectionName = null, IMongoCollection<T>? collection = null)
-            where TId : IComparable<TId>, IEquatable<TId>
-            where T : IEntity<TId>
+        /// <typeparam name="T">Any class</typeparam>
+        public Index<T> Index<T>(string? collectionName = null, IMongoCollection<T>? collection = null)
         {
-            return new Index<T, TId>(this, Collection(collectionName, collection));
+            return new Index<T>(this, Collection(collectionName, collection));
         }
+         
     }
 }
diff --git a/MongoDB.Entities/DBContext/DBContext.Replace.cs b/MongoDB.Entities/DBContext/DBContext.Replace.cs
index e3a8712b8..97135fc6e 100644
--- a/MongoDB.Entities/DBContext/DBContext.Replace.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Replace.cs
@@ -4,6 +4,14 @@ namespace MongoDB.Entities
 {
     public partial class DBContext
     {
+        /// <summary>
+        /// Starts a replace command for the given entity type
+        /// <para>TIP: Only the first matched entity will be replaced</para>
+        /// </summary>
+        /// <typeparam name="T">The type of entity</typeparam>
+        public Replace<T, string> Replace<T>(string? collectionName = null, IMongoCollection<T>? collection = null)
+            where T : IEntity => Replace<T, string>(collectionName, collection);
+
         /// <summary>
         /// Starts a replace command for the given entity type
         /// <para>TIP: Only the first matched entity will be replaced</para>
@@ -11,8 +19,8 @@ public partial class DBContext
         /// <typeparam name="T">The type of entity</typeparam>
         /// <typeparam name="TId">ID type</typeparam>
         public Replace<T, TId> Replace<T, TId>(string? collectionName = null, IMongoCollection<T>? collection = null)
-            where TId : IComparable<TId>, IEquatable<TId>
-            where T : IEntity<TId>
+        where TId : IComparable<TId>, IEquatable<TId>
+        where T : IEntity<TId>
         {
             ThrowIfModifiedByIsEmpty<T>();
             return new Replace<T, TId>(this, Collection(collectionName, collection), OnBeforeSave<T>);
diff --git a/MongoDB.Entities/DBContext/DBContext.Save.cs b/MongoDB.Entities/DBContext/DBContext.Save.cs
index 7c6182a70..3e2aca79d 100644
--- a/MongoDB.Entities/DBContext/DBContext.Save.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Save.cs
@@ -12,6 +12,18 @@ namespace MongoDB.Entities
 {
     public partial class DBContext
     {
+        /// <summary>
+        /// Saves a complete entity replacing an existing entity or creating a new one if it does not exist. 
+        /// If ID value is null, a new entity is created. If ID has a value, then existing entity is replaced.
+        /// </summary>
+        /// <typeparam name="T">The type of entity</typeparam>
+        /// <param name="entity">The instance to persist</param>
+        /// <param name="cancellation">And optional cancellation token</param>
+        /// <param name="collectionName"></param>
+        /// <param name="collection"></param>
+        public Task SaveAsync<T>(T entity, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null)
+            where T : IEntity => SaveAsync<T, string>(entity, cancellation, collectionName, collection);
+
         /// <summary>
         /// Saves a complete entity replacing an existing entity or creating a new one if it does not exist. 
         /// If ID value is null, a new entity is created. If ID has a value, then existing entity is replaced.
@@ -23,8 +35,8 @@ public partial class DBContext
         /// <param name="collectionName"></param>
         /// <param name="collection"></param>
         public Task SaveAsync<T, TId>(T entity, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null)
-            where TId : IComparable<TId>, IEquatable<TId>
-            where T : IEntity<TId>
+        where TId : IComparable<TId>, IEquatable<TId>
+        where T : IEntity<TId>
         {
             SetModifiedBySingle(entity);
             OnBeforeSave(entity);
diff --git a/MongoDB.Entities/DBContext/DBContext.Update.cs b/MongoDB.Entities/DBContext/DBContext.Update.cs
index 06114ed3a..d5b02b2c2 100644
--- a/MongoDB.Entities/DBContext/DBContext.Update.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Update.cs
@@ -2,14 +2,22 @@
 
 public partial class DBContext
 {
+    /// <summary>
+    /// Starts an update command for the given entity type
+    /// </summary>
+    /// <typeparam name="T">The type of entity</typeparam> 
+    public Update<T, string> Update<T>(string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
+        => Update<T, string>(collectionName: collectionName, collection: collection);
+
+
     /// <summary>
     /// Starts an update command for the given entity type
     /// </summary>
     /// <typeparam name="T">The type of entity</typeparam>
     /// <typeparam name="TId">ID type</typeparam>
     public Update<T, TId> Update<T, TId>(string? collectionName = null, IMongoCollection<T>? collection = null)
-        where TId : IComparable<TId>, IEquatable<TId>
-        where T : IEntity<TId>
+    where TId : IComparable<TId>, IEquatable<TId>
+    where T : IEntity<TId>
     {
         var cmd = new Update<T, TId>(this, Collection(collectionName, collection), OnBeforeUpdate<T, TId, Update<T, TId>>);
         if (Cache<T>().ModifiedByProp is PropertyInfo ModifiedByProp)
diff --git a/MongoDB.Entities/Relationships/NewMany.cs b/MongoDB.Entities/Relationships/NewMany.cs
index dc4a91654..6292646d6 100644
--- a/MongoDB.Entities/Relationships/NewMany.cs
+++ b/MongoDB.Entities/Relationships/NewMany.cs
@@ -124,7 +124,7 @@ protected Many(TParent parent, PropertyInfo parentProperty, PropertyInfo childPr
     {
         Parent = parent;
     }
-    public FilterDefinition<TChild> GetFilterForSingleDocument() => Builders<TChild>.Filter.Eq(ChildProperty.Name, Parent.ID);
+    public FilterDefinition<TChild> GetFilterForSingleDocument() => Builders<TChild>.Filter.Eq(ChildProperty.Name, /*TODO: uncomment me Parent.ID*/ "");
 }
 
 public sealed class ManyToMany<TParent, TChild> : Many<TParent, TChild>, IManyToMany<TParent, TChild>

From 899df7abaee8b18e3905419bc0aa9a9eb10a0684 Mon Sep 17 00:00:00 2001
From: Ahmed Fwela <ahmednfwela@bdaya-dev.com>
Date: Tue, 28 Dec 2021 07:15:59 +0200
Subject: [PATCH 26/26] WIP extensions

---
 MongoDB.Entities/Builders/Distinct.cs         |  2 +-
 MongoDB.Entities/Builders/PagedSearch.cs      |  2 +-
 MongoDB.Entities/Core/JoinRecordSerializer.cs |  2 +-
 MongoDB.Entities/Core/SequenceCounter.cs      |  2 +-
 MongoDB.Entities/DB/DB.cs                     |  4 +-
 .../DBContext/DBContext.Delete.cs             | 11 ++--
 .../DBContext/DBContext.Distinct.cs           |  6 +-
 .../DBContext/DBContext.Insert.cs             | 37 ++++++++++--
 .../DBContext/DBContext.PagedSearch.cs        | 14 ++---
 MongoDB.Entities/DBContext/DBContext.Save.cs  | 46 ++++++++++-----
 MongoDB.Entities/Extensions/Collection.cs     | 13 +++--
 MongoDB.Entities/Extensions/Database.cs       |  2 +-
 MongoDB.Entities/Extensions/Delete.cs         | 56 ++++++++++++++++---
 MongoDB.Entities/Extensions/Entity.cs         |  9 +--
 MongoDB.Entities/Extensions/Fluent.cs         |  9 +--
 MongoDB.Entities/Extensions/Insert.cs         | 18 +++---
 MongoDB.Entities/Extensions/PagedSearch.cs    |  8 +--
 MongoDB.Entities/Extensions/Save.cs           | 18 +++---
 .../Relationships/Many.Queryable.cs           |  8 +--
 19 files changed, 177 insertions(+), 90 deletions(-)

diff --git a/MongoDB.Entities/Builders/Distinct.cs b/MongoDB.Entities/Builders/Distinct.cs
index 1b6e59604..560d05d4b 100644
--- a/MongoDB.Entities/Builders/Distinct.cs
+++ b/MongoDB.Entities/Builders/Distinct.cs
@@ -35,7 +35,7 @@ public Task<IAsyncCursor<TProperty>> ExecuteCursorAsync(CancellationToken cancel
         if (_field == null)
             throw new InvalidOperationException("Please use the .Property() method to specify the field to use for obtaining unique values for!");
 
-        var mergedFilter = Logic.MergeWithGlobalFilter(_ignoreGlobalFilters, _globalFilters, _filter);
+        var mergedFilter = MergedFilter;
 
         return Context.Session is IClientSessionHandle session
                ? Collection.DistinctAsync(session, _field, mergedFilter, _options, cancellation)
diff --git a/MongoDB.Entities/Builders/PagedSearch.cs b/MongoDB.Entities/Builders/PagedSearch.cs
index 99f4941c7..b6ebb795a 100644
--- a/MongoDB.Entities/Builders/PagedSearch.cs
+++ b/MongoDB.Entities/Builders/PagedSearch.cs
@@ -30,7 +30,7 @@ internal PagedSearchBase(Dictionary<Type, (object filterDef, bool prepend)> glob
     /// <param name="fluentPipeline">The input IAggregateFluent pipeline</param>
     public TSelf WithFluent<TFluent>(TFluent fluentPipeline) where TFluent : IAggregateFluent<T>
     {
-        this._fluentPipeline = fluentPipeline;
+        _fluentPipeline = fluentPipeline;
         return This;
     }
 
diff --git a/MongoDB.Entities/Core/JoinRecordSerializer.cs b/MongoDB.Entities/Core/JoinRecordSerializer.cs
index 1483929c8..b0ed79dd5 100644
--- a/MongoDB.Entities/Core/JoinRecordSerializer.cs
+++ b/MongoDB.Entities/Core/JoinRecordSerializer.cs
@@ -9,7 +9,7 @@ public override void Serialize(BsonSerializationContext context, BsonSerializati
     }
     public override JoinRecord<T1, T2> Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args)
     {
-
+        return new JoinRecord<T1, T2>(default, default);
     }
 
     public bool TryGetMemberSerializationInfo(string memberName, out BsonSerializationInfo? serializationInfo)
diff --git a/MongoDB.Entities/Core/SequenceCounter.cs b/MongoDB.Entities/Core/SequenceCounter.cs
index 53528d9f1..1d8d62c9f 100644
--- a/MongoDB.Entities/Core/SequenceCounter.cs
+++ b/MongoDB.Entities/Core/SequenceCounter.cs
@@ -4,7 +4,7 @@
 internal class SequenceCounter : IEntity<string>
 {
     [BsonId]
-    public string ID { get; set; } = null!;
+    public string? ID { get; set; }
 
     [BsonRepresentation(BsonType.Int64)]
     public ulong Count { get; set; }
diff --git a/MongoDB.Entities/DB/DB.cs b/MongoDB.Entities/DB/DB.cs
index fc6b72146..a40930309 100644
--- a/MongoDB.Entities/DB/DB.cs
+++ b/MongoDB.Entities/DB/DB.cs
@@ -160,8 +160,8 @@ public static IMongoDatabase Database(string? name)
         /// Gets the name of the database a given entity type is attached to. Returns name of default database if not specifically attached.
         /// </summary>
         /// <typeparam name="T">Any class that implements IEntity</typeparam>
-        [Obsolete("This method returns the current DatabaseName in the Context")]
-        public static string DatabaseName<T>() where T : IEntity
+        [Obsolete("This method always returns the current DatabaseName in the Context")]
+        public static string DatabaseName<T>()
         {
             return Context.DatabaseNamespace.DatabaseName;
         }
diff --git a/MongoDB.Entities/DBContext/DBContext.Delete.cs b/MongoDB.Entities/DBContext/DBContext.Delete.cs
index 614e3b196..65887a016 100644
--- a/MongoDB.Entities/DBContext/DBContext.Delete.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Delete.cs
@@ -40,10 +40,11 @@ private async Task<DeleteResult> DeleteCascadingAsync<T, TId>(IEnumerable<TId?>
         var casted = IDs.Cast<object>();
         foreach (var cName in await collNamesCursor.ToListAsync(cancellation).ConfigureAwait(false))
         {
-            tasks.Add(
-                Session is null
-                ? Collection<JoinRecord<object, object>>(cName).DeleteManyAsync(r => casted.Contains(r.ID.ChildID) || casted.Contains(r.ID.ParentID))
-                : Collection<JoinRecord<object, object>>(cName).DeleteManyAsync(Session, r => casted.Contains(r.ID.ChildID) || casted.Contains(r.ID.ParentID), null, cancellation));
+            //TODO(@ahmednfwela): check if this is needed
+            //tasks.Add(
+            //    Session is null
+            //    ? Collection<JoinRecord<object, object>>(cName).DeleteManyAsync(r => casted.Contains(r.ID.ChildID) || casted.Contains(r.ID.ParentID))
+            //    : Collection<JoinRecord<object, object>>(cName).DeleteManyAsync(Session, r => casted.Contains(r.ID.ChildID) || casted.Contains(r.ID.ParentID), null, cancellation));
         }
 
         var delResTask =
@@ -164,7 +165,7 @@ public async Task<DeleteResult> DeleteAsync<T, TId>(FilterDefinition<T> filter,
         ThrowIfCancellationNotSupported(cancellation);
 
         var filterDef = Logic.MergeWithGlobalFilter(ignoreGlobalFilters, _globalFilters, filter);
-        var cursor = await new Find<T, TId, TId?>(this, Collection(collectionName, collection))
+        var cursor = await new Find<T, TId?>(this, Collection(collectionName, collection))
                            .Match(filter)
                            .Project(e => e.ID)
                            .Option(o => o.BatchSize = _deleteBatchSize)
diff --git a/MongoDB.Entities/DBContext/DBContext.Distinct.cs b/MongoDB.Entities/DBContext/DBContext.Distinct.cs
index d68d71cd8..de7a5a9f9 100644
--- a/MongoDB.Entities/DBContext/DBContext.Distinct.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Distinct.cs
@@ -10,10 +10,8 @@ public partial class DBContext
     /// <typeparam name="T">Any Entity that implements IEntity interface</typeparam>
     /// <typeparam name="TId">Id type</typeparam>
     /// <typeparam name="TProperty">The type of the property of the entity you'd like to get unique values for</typeparam>
-    public Distinct<T, TId, TProperty> Distinct<T, TId, TProperty>(string? collectionName = null, IMongoCollection<T>? collection = null)
-        where TId : IComparable<TId>, IEquatable<TId>
-        where T : IEntity<TId>
+    public Distinct<T, TProperty> Distinct<T, TId, TProperty>(string? collectionName = null, IMongoCollection<T>? collection = null)
     {
-        return new Distinct<T, TId, TProperty>(this, Collection(collectionName, collection));
+        return new Distinct<T, TProperty>(this, Collection(collectionName, collection));
     }
 }
diff --git a/MongoDB.Entities/DBContext/DBContext.Insert.cs b/MongoDB.Entities/DBContext/DBContext.Insert.cs
index 3617b3eb2..2f0b45681 100644
--- a/MongoDB.Entities/DBContext/DBContext.Insert.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Insert.cs
@@ -18,7 +18,7 @@ private Task<UpdateResult> SavePartial<T, TId>(T entity, Expression<Func<T, obje
         {
             PrepAndCheckIfInsert<T, TId>(entity); //just prep. we don't care about inserts here
             var filter = Builders<T>.Filter.Eq(e => e.ID, entity.ID);
-            var update = Builders<T>.Update.Combine(Logic.BuildUpdateDefs<T, TId>(entity, members, this, excludeMode));
+            var update = Builders<T>.Update.Combine(Logic.BuildUpdateDefs(entity, members, this, excludeMode));
             return
                 Session == null
                 ? Collection(collectionName, collection).UpdateOneAsync(filter, update, _updateOptions, cancellation)
@@ -34,7 +34,7 @@ private Task<BulkWriteResult<T>> SavePartial<T, TId>(IEnumerable<T> entities, Ex
                 PrepAndCheckIfInsert<T, TId>(ent); //just prep. we don't care about inserts here
                 return new UpdateOneModel<T>(
                             filter: Builders<T>.Filter.Eq(e => e.ID, ent.ID),
-                            update: Builders<T>.Update.Combine(Logic.BuildUpdateDefs<T, TId>(ent, members, this, excludeMode)))
+                            update: Builders<T>.Update.Combine(Logic.BuildUpdateDefs(ent, members, this, excludeMode)))
                 { IsUpsert = true };
             }).ToList();
             return Session == null
@@ -59,6 +59,7 @@ private bool PrepAndCheckIfInsert<T, TId>(T entity)
             return false;
         }
 
+
         /// <summary>
         /// Saves a complete entity replacing an existing entity or creating a new one if it does not exist. 
         /// If ID value is null, a new entity is created. If ID has a value, then existing entity is replaced.
@@ -70,7 +71,7 @@ private bool PrepAndCheckIfInsert<T, TId>(T entity)
         /// <param name="collectionName"></param>
         /// <param name="collection"></param>
         public Task InsertAsync<T, TId>(T entity, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null)
-                     where TId : IComparable<TId>, IEquatable<TId>
+            where TId : IComparable<TId>, IEquatable<TId>
             where T : IEntity<TId>
         {
             SetModifiedBySingle(entity);
@@ -81,6 +82,19 @@ public Task InsertAsync<T, TId>(T entity, CancellationToken cancellation = defau
                    : Collection(collectionName, collection).InsertOneAsync(Session, entity, null, cancellation);
         }
 
+        /// <summary>
+        /// Saves a complete entity replacing an existing entity or creating a new one if it does not exist. 
+        /// If ID value is null, a new entity is created. If ID has a value, then existing entity is replaced.
+        /// </summary>
+        /// <typeparam name="T">The type of entity</typeparam>
+        /// <param name="entity">The instance to persist</param>
+        /// <param name="cancellation">And optional cancellation token</param>
+        /// <param name="collectionName"></param>
+        /// <param name="collection"></param>
+        public Task InsertAsync<T>(T entity, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null)
+            where T : IEntity
+            => InsertAsync<T, string>(entity, cancellation, collectionName, collection);
+
         /// <summary>
         /// Saves a batch of complete entities replacing an existing entities or creating a new ones if they do not exist. 
         /// If ID value is null, a new entity is created. If ID has a value, then existing entity is replaced.
@@ -92,7 +106,7 @@ public Task InsertAsync<T, TId>(T entity, CancellationToken cancellation = defau
         /// <param name="collectionName"></param>
         /// <param name="collection"></param>
         public Task<BulkWriteResult<T>> InsertAsync<T, TId>(IEnumerable<T> entities, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null)
-                     where TId : IComparable<TId>, IEquatable<TId>
+            where TId : IComparable<TId>, IEquatable<TId>
             where T : IEntity<TId>
         {
             SetModifiedByMultiple(entities);
@@ -108,5 +122,20 @@ public Task<BulkWriteResult<T>> InsertAsync<T, TId>(IEnumerable<T> entities, Can
                    ? Collection(collectionName, collection).BulkWriteAsync(models, _unOrdBlkOpts, cancellation)
                    : Collection(collectionName, collection).BulkWriteAsync(Session, models, _unOrdBlkOpts, cancellation);
         }
+
+        /// <summary>
+        /// Saves a batch of complete entities replacing an existing entities or creating a new ones if they do not exist. 
+        /// If ID value is null, a new entity is created. If ID has a value, then existing entity is replaced.
+        /// </summary>
+        /// <typeparam name="T">The type of entity</typeparam>
+        /// <param name="entities">The entities to persist</param>
+        /// <param name="cancellation">And optional cancellation token</param>
+        /// <param name="collectionName"></param>
+        /// <param name="collection"></param>
+        public Task<BulkWriteResult<T>> InsertAsync<T>(IEnumerable<T> entities, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null)
+            where T : IEntity
+        {
+            return InsertAsync<T, string>(entities, cancellation, collectionName, collection);
+        }
     }
 }
diff --git a/MongoDB.Entities/DBContext/DBContext.PagedSearch.cs b/MongoDB.Entities/DBContext/DBContext.PagedSearch.cs
index 56e9d1412..625d124b4 100644
--- a/MongoDB.Entities/DBContext/DBContext.PagedSearch.cs
+++ b/MongoDB.Entities/DBContext/DBContext.PagedSearch.cs
@@ -8,24 +8,18 @@ public partial class DBContext
     /// Represents an aggregation query that retrieves results with easy paging support.
     /// </summary>
     /// <typeparam name="T">Any class that implements IEntity</typeparam>
-    /// <typeparam name="TId">ID type</typeparam>
-    public PagedSearch<T, TId> PagedSearch<T, TId>(string? collectionName = null, IMongoCollection<T>? collection = null)
-        where TId : IComparable<TId>, IEquatable<TId>
-        where T : IEntity<TId>
+    public PagedSearch<T> PagedSearch<T>(string? collectionName = null, IMongoCollection<T>? collection = null)
     {
-        return new PagedSearch<T, TId>(this, Collection(collectionName, collection));
+        return new PagedSearch<T>(this, Collection(collectionName, collection));
     }
 
     /// <summary>
     /// Represents an aggregation query that retrieves results with easy paging support.
     /// </summary>
     /// <typeparam name="T">Any class that implements IEntity</typeparam>
-    /// <typeparam name="TId">ID type</typeparam>
     /// <typeparam name="TProjection">The type you'd like to project the results to.</typeparam>
-    public PagedSearch<T, TId, TProjection> PagedSearch<T, TId, TProjection>(string? collectionName = null, IMongoCollection<T>? collection = null)
-        where TId : IComparable<TId>, IEquatable<TId>
-        where T : IEntity<TId>
+    public PagedSearch<T, TProjection> PagedSearch<T, TProjection>(string? collectionName = null, IMongoCollection<T>? collection = null)
     {
-        return new PagedSearch<T, TId, TProjection>(this, Collection(collectionName, collection));
+        return new PagedSearch<T, TProjection>(this, Collection(collectionName, collection));
     }
 }
diff --git a/MongoDB.Entities/DBContext/DBContext.Save.cs b/MongoDB.Entities/DBContext/DBContext.Save.cs
index 3e2aca79d..0c6a27b60 100644
--- a/MongoDB.Entities/DBContext/DBContext.Save.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Save.cs
@@ -12,17 +12,6 @@ namespace MongoDB.Entities
 {
     public partial class DBContext
     {
-        /// <summary>
-        /// Saves a complete entity replacing an existing entity or creating a new one if it does not exist. 
-        /// If ID value is null, a new entity is created. If ID has a value, then existing entity is replaced.
-        /// </summary>
-        /// <typeparam name="T">The type of entity</typeparam>
-        /// <param name="entity">The instance to persist</param>
-        /// <param name="cancellation">And optional cancellation token</param>
-        /// <param name="collectionName"></param>
-        /// <param name="collection"></param>
-        public Task SaveAsync<T>(T entity, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null)
-            where T : IEntity => SaveAsync<T, string>(entity, cancellation, collectionName, collection);
 
         /// <summary>
         /// Saves a complete entity replacing an existing entity or creating a new one if it does not exist. 
@@ -35,8 +24,8 @@ public Task SaveAsync<T>(T entity, CancellationToken cancellation = default, str
         /// <param name="collectionName"></param>
         /// <param name="collection"></param>
         public Task SaveAsync<T, TId>(T entity, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null)
-        where TId : IComparable<TId>, IEquatable<TId>
-        where T : IEntity<TId>
+            where TId : IComparable<TId>, IEquatable<TId>
+            where T : IEntity<TId>
         {
             SetModifiedBySingle(entity);
             OnBeforeSave(entity);
@@ -53,6 +42,19 @@ public Task SaveAsync<T, TId>(T entity, CancellationToken cancellation = default
                    : collection.ReplaceOneAsync(Session, filter, entity, new ReplaceOptions { IsUpsert = true }, cancellation);
         }
 
+        /// <summary>
+        /// Saves a complete entity replacing an existing entity or creating a new one if it does not exist. 
+        /// If ID value is null, a new entity is created. If ID has a value, then existing entity is replaced.
+        /// </summary>
+        /// <typeparam name="T">The type of entity</typeparam>
+        /// <param name="entity">The instance to persist</param>
+        /// <param name="cancellation">And optional cancellation token</param>
+        /// <param name="collectionName"></param>
+        /// <param name="collection"></param>
+        public Task SaveAsync<T>(T entity, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null)
+            where T : IEntity => SaveAsync<T, string>(entity, cancellation, collectionName, collection);
+
+
         /// <summary>
         /// Saves a batch of complete entities replacing an existing entities or creating a new ones if they do not exist. 
         /// If ID value is null, a new entity is created. If ID has a value, then existing entity is replaced.
@@ -64,7 +66,7 @@ public Task SaveAsync<T, TId>(T entity, CancellationToken cancellation = default
         /// <param name="collectionName"></param>
         /// <param name="collection"></param>
         public Task<BulkWriteResult<T>> SaveAsync<T, TId>(IEnumerable<T> entities, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null)
-             where TId : IComparable<TId>, IEquatable<TId>
+            where TId : IComparable<TId>, IEquatable<TId>
             where T : IEntity<TId>
         {
             SetModifiedByMultiple(entities);
@@ -91,6 +93,22 @@ public Task<BulkWriteResult<T>> SaveAsync<T, TId>(IEnumerable<T> entities, Cance
                    : Collection(collectionName, collection).BulkWriteAsync(Session, models, _unOrdBlkOpts, cancellation);
         }
 
+
+        /// <summary>
+        /// Saves a batch of complete entities replacing an existing entities or creating a new ones if they do not exist. 
+        /// If ID value is null, a new entity is created. If ID has a value, then existing entity is replaced.
+        /// </summary>
+        /// <typeparam name="T">The type of entity</typeparam>
+        /// <param name="entities">The entities to persist</param>
+        /// <param name="cancellation">And optional cancellation token</param>
+        /// <param name="collectionName"></param>
+        /// <param name="collection"></param>
+        public Task<BulkWriteResult<T>> SaveAsync<T>(IEnumerable<T> entities, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null)
+            where T : IEntity
+        {
+            return SaveAsync<T, string>(entities: entities, cancellation: cancellation, collectionName: collectionName, collection: collection);
+        }
+
         /// <summary>
         /// Saves an entity partially with only the specified subset of properties. 
         /// If ID value is null, a new entity is created. If ID has a value, then existing entity is updated.
diff --git a/MongoDB.Entities/Extensions/Collection.cs b/MongoDB.Entities/Extensions/Collection.cs
index 1597a3a36..32a67e7be 100644
--- a/MongoDB.Entities/Extensions/Collection.cs
+++ b/MongoDB.Entities/Extensions/Collection.cs
@@ -9,16 +9,19 @@ public static partial class Extensions
         /// Gets the IMongoCollection for a given IEntity type.
         /// <para>TIP: Try never to use this unless really neccessary.</para>
         /// </summary>
-        /// <typeparam name="T">Any class that implements IEntity</typeparam>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static IMongoCollection<T> Collection<T>(this T _, string tenantPrefix) where T : IEntity => DB.Collection<T>(tenantPrefix);
+        /// <typeparam name="T">Any class</typeparam>
+        /// <param name="_"></param>
+        /// <param name="collectionName"></param>
+        /// <param name="collection"></param>
+        public static IMongoCollection<T> Collection<T>(this T _, string? collectionName = null, IMongoCollection<T>? collection = null)
+            => DB.Context.Collection(collectionName: collectionName, collection: collection);
 
         /// <summary>
         /// Gets the collection name for this entity
         /// </summary>
-        public static string CollectionName<T>(this T _) where T : IEntity
+        public static string CollectionName<T>(this T _)
         {
-            return DB.CollectionName<T>();
+            return DB.Context.CollectionName<T>();
         }
 
         /// <summary>
diff --git a/MongoDB.Entities/Extensions/Database.cs b/MongoDB.Entities/Extensions/Database.cs
index 6e3883e03..849c764d6 100644
--- a/MongoDB.Entities/Extensions/Database.cs
+++ b/MongoDB.Entities/Extensions/Database.cs
@@ -19,7 +19,7 @@ public static partial class Extensions
     /// Gets the name of the database this entity is attached to. Returns name of default database if not specifically attached.
     /// </summary>
     [Obsolete("This method returns the current DatabaseName in the Context")]
-    public static string DatabaseName<T>(this T _, string tenantPrefix) where T : IEntity => DB.DatabaseName<T>();
+    public static string DatabaseName<T>(this T _, string tenantPrefix) => DB.DatabaseName<T>();
 
     /// <summary>
     /// Pings the mongodb server to check if it's still connectable
diff --git a/MongoDB.Entities/Extensions/Delete.cs b/MongoDB.Entities/Extensions/Delete.cs
index 8e221aa82..a47ee31f4 100644
--- a/MongoDB.Entities/Extensions/Delete.cs
+++ b/MongoDB.Entities/Extensions/Delete.cs
@@ -13,25 +13,63 @@ public static partial class Extensions
         /// <para>HINT: If this entity is referenced by one-to-many/many-to-many relationships, those references are also deleted.</para>
         /// </summary>
         /// <param name="entity"></param>
-        /// <param name="session"></param>
         /// <param name="cancellation">An optional cancellation token</param>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static Task<DeleteResult> DeleteAsync<T>(this T entity, IClientSessionHandle session = null, CancellationToken cancellation = default, string tenantPrefix = null) where T : IEntity
+        /// <param name="ignoreGlobalFilters"></param>
+        /// <param name="collectionName"></param>
+        /// <param name="collection"></param>
+        public static Task<DeleteResult> DeleteAsync<T, TId>(this T entity, CancellationToken cancellation = default, bool ignoreGlobalFilters = false, string? collectionName = null, IMongoCollection<T>? collection = null)
+            where TId : IEquatable<TId>, IComparable<TId>
+            where T : IEntity<TId>
         {
-            return DB.DeleteAsync<T>(entity.ID, session, cancellation, tenantPrefix);
+            entity.ThrowIfUnsaved();
+            return DB.Context.DeleteAsync(entity.ID!, cancellation, ignoreGlobalFilters: ignoreGlobalFilters, collectionName: collectionName, collection: collection);
+        }
+
+        /// <summary>
+        /// Deletes a single entity from MongoDB.
+        /// <para>HINT: If this entity is referenced by one-to-many/many-to-many relationships, those references are also deleted.</para>
+        /// </summary>
+        /// <param name="entity"></param>
+        /// <param name="cancellation">An optional cancellation token</param>
+        /// <param name="ignoreGlobalFilters"></param>
+        /// <param name="collectionName"></param>
+        /// <param name="collection"></param>
+        public static Task<DeleteResult> DeleteAsync<T>(this T entity, CancellationToken cancellation = default, bool ignoreGlobalFilters = false, string? collectionName = null, IMongoCollection<T>? collection = null)
+            where T : IEntity
+        {
+            return DeleteAsync<T, string>(entity, cancellation, ignoreGlobalFilters: ignoreGlobalFilters, collectionName: collectionName, collection: collection);
+        }
+
+
+        /// <summary>
+        /// Deletes multiple entities from the database
+        /// <para>HINT: If these entities are referenced by one-to-many/many-to-many relationships, those references are also deleted.</para>
+        /// </summary>
+        /// <param name="entities"></param>        
+        /// <param name="cancellation">An optional cancellation token</param>
+        /// <param name="ignoreGlobalFilters"></param>
+        /// <param name="collectionName"></param>
+        /// <param name="collection"></param>        
+        public static Task<DeleteResult> DeleteAllAsync<T>(this IEnumerable<T> entities, CancellationToken cancellation = default, bool ignoreGlobalFilters = false, string? collectionName = null, IMongoCollection<T>? collection = null)
+            where T : IEntity
+        {
+            return DeleteAllAsync<T, string>(entities, cancellation: cancellation, ignoreGlobalFilters: ignoreGlobalFilters, collectionName: collectionName, collection: collection);
         }
 
         /// <summary>
         /// Deletes multiple entities from the database
         /// <para>HINT: If these entities are referenced by one-to-many/many-to-many relationships, those references are also deleted.</para>
         /// </summary>
-        /// <param name="entities"></param>
-        /// <param name="session"></param>
+        /// <param name="entities"></param>        
         /// <param name="cancellation">An optional cancellation token</param>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static Task<DeleteResult> DeleteAllAsync<T>(this IEnumerable<T> entities, IClientSessionHandle session = null, CancellationToken cancellation = default, string tenantPrefix = null) where T : IEntity
+        /// <param name="ignoreGlobalFilters"></param>
+        /// <param name="collectionName"></param>
+        /// <param name="collection"></param>        
+        public static Task<DeleteResult> DeleteAllAsync<T, TId>(this IEnumerable<T> entities, CancellationToken cancellation = default, bool ignoreGlobalFilters = false, string? collectionName = null, IMongoCollection<T>? collection = null)
+            where TId : IEquatable<TId>, IComparable<TId>
+            where T : IEntity<TId>
         {
-            return DB.DeleteAsync<T>(entities.Select(e => e.ID), session, cancellation, tenantPrefix);
+            return DB.Context.DeleteAsync<T, TId>(IDs: entities.Select(e => e.ID!), cancellation: cancellation, ignoreGlobalFilters: ignoreGlobalFilters, collectionName: collectionName, collection: collection);
         }
 
     }
diff --git a/MongoDB.Entities/Extensions/Entity.cs b/MongoDB.Entities/Extensions/Entity.cs
index 4c26ec4e2..d6bec53b3 100644
--- a/MongoDB.Entities/Extensions/Entity.cs
+++ b/MongoDB.Entities/Extensions/Entity.cs
@@ -36,6 +36,7 @@ internal static void ThrowIfUnsaved<TId>(this TId? id) where TId : IComparable<T
                 throw new InvalidOperationException("Please save the entity before performing this operation!");
         }
 
+        //TODO(@ahmednfwela): add static analysis attributes
         internal static void ThrowIfUnsaved<TId>(this IEntity<TId> entity) where TId : IComparable<TId>, IEquatable<TId>
         {
             ThrowIfUnsaved(entity.ID);
@@ -77,9 +78,9 @@ public static string FullPath<T, TProp>(this Expression<Func<T, TProp>> expressi
         /// <summary>
         /// An IQueryable collection of sibling Entities.
         /// </summary>
-        public static IMongoQueryable<T> Queryable<T>(this T _, AggregateOptions? options = null, string? tenantPrefix = null) where T : IEntity
+        public static IMongoQueryable<T> Queryable<T>(this T _, AggregateOptions? options = null, bool ignoreGlobalFilters = false, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
         {
-            return DB.Queryable<T>(options);
+            return DB.Context.Queryable(options, collectionName: collectionName, collection: collection, ignoreGlobalFilters: ignoreGlobalFilters);
         }
 
         /// <summary>
@@ -167,9 +168,9 @@ string RemoveDiacritics(string text)
         /// <param name="_"></param>
         /// <param name="cancellation">An optional cancellation token</param>
         /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static Task<ulong> NextSequentialNumberAsync<T>(this T _, CancellationToken cancellation = default, string tenantPrefix = null) where T : IEntity
+        public static Task<ulong> NextSequentialNumberAsync<T>(this T _, CancellationToken cancellation = default) where T : IEntity
         {
-            return DB.NextSequentialNumberAsync<T>(cancellation, tenantPrefix);
+            return DB.Context.NextSequentialNumberAsync<T>(cancellation);
         }
     }
 }
diff --git a/MongoDB.Entities/Extensions/Fluent.cs b/MongoDB.Entities/Extensions/Fluent.cs
index 0ea4af8d4..1715d87ec 100644
--- a/MongoDB.Entities/Extensions/Fluent.cs
+++ b/MongoDB.Entities/Extensions/Fluent.cs
@@ -10,12 +10,13 @@ public static partial class Extensions
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <param name="_"></param>
-        /// <param name="session">An optional session if using within a transaction</param>
         /// <param name="options">The options for the aggregation. This is not required.</param>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static IAggregateFluent<T> Fluent<T>(this T _, IClientSessionHandle session = null, AggregateOptions options = null, string tenantPrefix = null) where T : IEntity
+        /// <param name="ignoreGlobalFilters"></param>
+        /// <param name="collectionName"></param>
+        /// <param name="collection"></param>
+        public static IAggregateFluent<T> Fluent<T>(this T _, AggregateOptions? options = null, bool ignoreGlobalFilters = false, string? collectionName = null, IMongoCollection<T>? collection = null) where T : IEntity
         {
-            return DB.Fluent<T>(options, session, tenantPrefix);
+            return DB.Context.Fluent(options, ignoreGlobalFilters: ignoreGlobalFilters, collection: collection, collectionName: collectionName);
         }
 
         /// <summary>
diff --git a/MongoDB.Entities/Extensions/Insert.cs b/MongoDB.Entities/Extensions/Insert.cs
index 089ed32f1..483a88686 100644
--- a/MongoDB.Entities/Extensions/Insert.cs
+++ b/MongoDB.Entities/Extensions/Insert.cs
@@ -11,24 +11,26 @@ public static partial class Extensions
         /// Inserts a new entity into the colleciton.
         /// </summary>
         /// <param name="entity"></param>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        /// <param name="session">An optional session if using within a transaction</param>
         /// <param name="cancellation">An optional cancellation token</param>
-        public static Task InsertAsync<T>(this T entity, string tenantPrefix, IClientSessionHandle session = null, CancellationToken cancellation = default) where T : IEntity
+        /// <param name="collectionName"></param>
+        /// <param name="collection"></param>
+        public static Task InsertAsync<T>(this T entity, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null)
+            where T : IEntity
         {
-            return DB.InsertAsync(entity, session, cancellation, tenantPrefix);
+            return DB.Context.InsertAsync(entity, cancellation, collectionName, collection);
         }
 
         /// <summary>
         /// Inserts a batch of new entities into the collection.
         /// </summary>
         /// <param name="entities"></param>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        /// <param name="session">An optional session if using within a transaction</param>
         /// <param name="cancellation">An optional cancellation token</param>
-        public static Task<BulkWriteResult<T>> InsertAsync<T>(this IEnumerable<T> entities, string tenantPrefix, IClientSessionHandle session = null, CancellationToken cancellation = default) where T : IEntity
+        /// <param name="collectionName"></param>
+        /// <param name="collection"></param>
+        public static Task<BulkWriteResult<T>> InsertAsync<T>(this IEnumerable<T> entities, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null)
+            where T : IEntity
         {
-            return DB.InsertAsync(entities, session, cancellation, tenantPrefix);
+            return DB.Context.InsertAsync(entities, cancellation, collectionName: collectionName, collection: collection);
         }
 
     }
diff --git a/MongoDB.Entities/Extensions/PagedSearch.cs b/MongoDB.Entities/Extensions/PagedSearch.cs
index 6c8f09513..0a8b50745 100644
--- a/MongoDB.Entities/Extensions/PagedSearch.cs
+++ b/MongoDB.Entities/Extensions/PagedSearch.cs
@@ -9,18 +9,18 @@ public static partial class Extensions
         /// </summary>
         /// <typeparam name="T">Any class that implements IEntity</typeparam>
         /// <typeparam name="TProjection">The type of the resulting projection</typeparam>
-        public static PagedSearch<T, TProjection> PagedSearch<T, TProjection>(this IAggregateFluent<T> aggregate, string tenantPrefix) where T : IEntity
+        public static PagedSearch<T, TProjection> PagedSearch<T, TProjection>(this IAggregateFluent<T> aggregate, string? collectionName = null, IMongoCollection<T>? collection = null)
         {
-            return DB.PagedSearch<T, TProjection>(tenantPrefix: tenantPrefix).WithFluent(aggregate);
+            return DB.Context.PagedSearch<T, TProjection>(collectionName: collectionName, collection: collection).WithFluent(aggregate);
         }
 
         /// <summary>
         /// Starts a paged search pipeline for this fluent pipeline
         /// </summary>
         /// <typeparam name="T">Any class that implements IEntity</typeparam>
-        public static PagedSearch<T, T> PagedSearch<T>(this IAggregateFluent<T> aggregate, string tenantPrefix) where T : IEntity
+        public static PagedSearch<T, T> PagedSearch<T>(this IAggregateFluent<T> aggregate, string? collectionName = null, IMongoCollection<T>? collection = null)
         {
-            return DB.PagedSearch<T, T>(tenantPrefix: tenantPrefix).WithFluent(aggregate);
+            return DB.Context.PagedSearch<T, T>(collectionName: collectionName, collection: collection).WithFluent(aggregate);
         }
     }
 }
diff --git a/MongoDB.Entities/Extensions/Save.cs b/MongoDB.Entities/Extensions/Save.cs
index 5ef05d47f..6d9aa5417 100644
--- a/MongoDB.Entities/Extensions/Save.cs
+++ b/MongoDB.Entities/Extensions/Save.cs
@@ -14,12 +14,13 @@ public static partial class Extensions
         /// If ID value is null, a new entity is created. If ID has a value, then existing entity is replaced.
         /// </summary>
         /// <param name="entity"></param>
-        /// <param name="session">An optional session if using within a transaction</param>
         /// <param name="cancellation">An optional cancellation token</param>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static Task SaveAsync<T>(this T entity, IClientSessionHandle session = null, CancellationToken cancellation = default, string tenantPrefix = null) where T : IEntity
+        /// <param name="collectionName"></param>
+        /// <param name="collection"></param>
+        public static Task SaveAsync<T>(this T entity, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null)
+            where T : IEntity
         {
-            return DB.SaveAsync(entity, session, cancellation, tenantPrefix);
+            return DB.Context.SaveAsync(entity, cancellation: cancellation, collectionName: collectionName, collection: collection);
         }
 
         /// <summary>
@@ -27,12 +28,13 @@ public static Task SaveAsync<T>(this T entity, IClientSessionHandle session = nu
         /// If ID value is null, a new entity is created. If ID has a value, then existing entity is replaced.
         /// </summary>
         /// <param name="entities"></param>
-        /// <param name="session">An optional session if using within a transaction</param>
         /// <param name="cancellation">An optional cancellation token</param>
-        /// <param name="tenantPrefix">Optional tenant prefix if using multi-tenancy</param>
-        public static Task<BulkWriteResult<T>> SaveAsync<T>(this IEnumerable<T> entities, IClientSessionHandle session = null, CancellationToken cancellation = default, string tenantPrefix = null) where T : IEntity
+        /// <param name="collectionName"></param>
+        /// <param name="collection"></param>
+        public static Task<BulkWriteResult<T>> SaveAsync<T>(this IEnumerable<T> entities, CancellationToken cancellation = default, string? collectionName = null, IMongoCollection<T>? collection = null)
+            where T : IEntity
         {
-            return DB.SaveAsync(entities, session, cancellation, tenantPrefix);
+            return DB.Context.SaveAsync(entities: entities, cancellation, collectionName: collectionName, collection: collection);
         }
 
         /// <summary>
diff --git a/MongoDB.Entities/Relationships/Many.Queryable.cs b/MongoDB.Entities/Relationships/Many.Queryable.cs
index 26b0f392e..b1834440e 100644
--- a/MongoDB.Entities/Relationships/Many.Queryable.cs
+++ b/MongoDB.Entities/Relationships/Many.Queryable.cs
@@ -49,7 +49,7 @@ public IMongoQueryable<TParent> ParentsQueryable<TParent>(IEnumerable<string> ch
             return JoinQueryable(session, options)
                    .Where(j => childIDs.Contains(j.ParentID))
                    .Join(
-                       DB.Collection<TParent>(null),
+                       DB.Context.Collection<TParent>(null),
                        j => j.ChildID,
                        p => p.ID,
                        (_, p) => p)
@@ -60,7 +60,7 @@ public IMongoQueryable<TParent> ParentsQueryable<TParent>(IEnumerable<string> ch
             return JoinQueryable(session, options)
                    .Where(j => childIDs.Contains(j.ChildID))
                    .Join(
-                       DB.Collection<TParent>(null),
+                       DB.Context.Collection<TParent>(null),
                        j => j.ParentID,
                        p => p.ID,
                        (_, p) => p)
@@ -125,7 +125,7 @@ public IMongoQueryable<TChild> ChildrenQueryable(IClientSessionHandle session =
             return JoinQueryable(session, options)
                    .Where(j => j.ChildID == parent.ID)
                    .Join(
-                       DB.Collection<TChild>(null),
+                       DB.Context.Collection<TChild>(null),
                        j => j.ParentID,
                        c => c.ID,
                        (_, c) => c);
@@ -135,7 +135,7 @@ public IMongoQueryable<TChild> ChildrenQueryable(IClientSessionHandle session =
             return JoinQueryable(session, options)
                    .Where(j => j.ParentID == parent.ID)
                    .Join(
-                       DB.Collection<TChild>(null),
+                       DB.Context.Collection<TChild>(null),
                        j => j.ChildID,
                        c => c.ID,
                        (_, c) => c);