NoSqlHelper.cs

#region Related components
using System;
using System.Linq;
using System.Diagnostics;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Concurrent;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;
using MongoDB.Bson;
using MongoDB.Bson.IO;
using MongoDB.Bson.Serialization;
using MongoDB.Bson.Serialization.Attributes;
using MongoDB.Bson.Serialization.Serializers;
using MongoDB.Driver;
using Newtonsoft.Json.Linq;
using net.vieapps.Components.Utility;
#endregion

namespace net.vieapps.Components.Repository
{
	/// <summary>
	/// Collection of methods for working with NoSQL database (MongoDB)
	/// </summary>
	public static class NoSqlHelper
	{
		static string AllowDiskUse { get; } = UtilityService.GetAppSetting("Components:Repository:NoSql:AllowDiskUse", "true");

		static string AllowPartialResults { get; } = UtilityService.GetAppSetting("Components:Repository:NoSql:AllowPartialResults");

		static string MinConnectionPoolSize { get; } = UtilityService.GetAppSetting("Components:Repository:NoSql:MinConnectionPoolSize");

		static string MaxConnectionPoolSize { get; } = UtilityService.GetAppSetting("Components:Repository:NoSql:MaxConnectionPoolSize");

		static string MaxConnecting { get; } = UtilityService.GetAppSetting("Components:Repository:NoSql:MaxConnecting");

		#region Client
		internal static ConcurrentDictionary<string, IMongoClient> Clients { get; } = new ConcurrentDictionary<string, IMongoClient>();

		internal static ConcurrentDictionary<int, bool> ReplicaSetClients { get; } = new ConcurrentDictionary<int, bool>();

		/// <summary>
		/// Checks to see client is connected to a ReplicaSet or not
		/// </summary>
		/// <param name="mongoClient"></param>
		/// <returns></returns>
		public static bool IsReplicaSet(this IMongoClient mongoClient)
		{
			if (NoSqlHelper.ReplicaSetClients.TryGetValue(mongoClient.GetHashCode(), out var status))
				return status;

			try
			{
				var statusDoc = mongoClient.GetDatabase("admin").RunCommand<BsonDocument>("{ replSetGetStatus: 1 }");
				status = statusDoc.Contains("replSet");
			}
			catch
			{
				status = false;
			}

			NoSqlHelper.ReplicaSetClients.TryAdd(mongoClient.GetHashCode(), status);
			return status;
		}

		/// <summary>
		/// Checks to see client is connected to a ReplicaSet or not
		/// </summary>
		/// <param name="mongoClient"></param>
		/// <returns></returns>
		public static async Task<bool> IsReplicaSetAsync(this IMongoClient mongoClient, CancellationToken cancellationToken = default)
		{
			if (NoSqlHelper.ReplicaSetClients.TryGetValue(mongoClient.GetHashCode(), out var status))
				return status;

			try
			{
				var statusDoc = await mongoClient.GetDatabase("admin").RunCommandAsync<BsonDocument>("{ replSetGetStatus: 1 }", null, cancellationToken).ConfigureAwait(false);
				status = statusDoc.Contains("replSet");
			}
			catch
			{
				status = false;
			}

			NoSqlHelper.ReplicaSetClients.TryAdd(mongoClient.GetHashCode(), status);
			return status;
		}

		/// <summary>
		/// Gets a client for working with MongoDB
		/// </summary>
		/// <param name="connectionString"></param>
		/// <returns></returns>
		public static IMongoClient GetClient(string connectionString)
		{
			if (string.IsNullOrWhiteSpace(connectionString))
				return null;

			var key = "MongoClient#" + connectionString.Trim().ToLower().GenerateUUID();
			if (!NoSqlHelper.Clients.TryGetValue(key, out var client))
				lock (NoSqlHelper.Clients)
				{
					if (!NoSqlHelper.Clients.TryGetValue(key, out client))
					{
						var settings = MongoClientSettings.FromConnectionString(connectionString);
						if (Int32.TryParse(NoSqlHelper.MinConnectionPoolSize, out var minConnectionPoolSize))
							settings.MinConnectionPoolSize = minConnectionPoolSize;
						if (Int32.TryParse(NoSqlHelper.MaxConnectionPoolSize, out var maxConnectionPoolSize))
							settings.MaxConnectionPoolSize = maxConnectionPoolSize;
						if (Int32.TryParse(NoSqlHelper.MaxConnecting, out var maxConnecting))
							settings.MaxConnecting = maxConnecting;
						client = new MongoClient(settings);
						NoSqlHelper.Clients.TryAdd(key, client);
					}
				}
			return client;
		}
		#endregion

		#region Database
		/// <summary>
		/// Gets a database of MongoDB
		/// </summary>
		/// <param name="mongoClient"></param>
		/// <param name="databaseName"></param>
		/// <param name="databaseSettings"></param>
		/// <returns></returns>
		public static IMongoDatabase GetDatabase(IMongoClient mongoClient, string databaseName, MongoDatabaseSettings databaseSettings = null)
			=> !string.IsNullOrWhiteSpace(databaseName) && mongoClient != null
				? mongoClient.GetDatabase(databaseName, databaseSettings)
				: null;

		internal static ConcurrentDictionary<string, IMongoDatabase> Databases { get; } = new ConcurrentDictionary<string, IMongoDatabase>();

		/// <summary>
		/// Gets a database of MongoDB
		/// </summary>
		/// <param name="connectionString"></param>
		/// <param name="databaseName"></param>
		/// <param name="databaseSettings"></param>
		/// <returns></returns>
		public static IMongoDatabase GetDatabase(string connectionString, string databaseName, MongoDatabaseSettings databaseSettings = null)
		{
			if (string.IsNullOrWhiteSpace(connectionString) || string.IsNullOrWhiteSpace(databaseName))
				return null;

			var key = databaseName.Trim() + "#" + connectionString.Trim().ToLower().GenerateUUID();
			if (!NoSqlHelper.Databases.TryGetValue(key, out var database))
				lock (NoSqlHelper.Databases)
				{
					if (!NoSqlHelper.Databases.TryGetValue(key, out database))
					{
						database = NoSqlHelper.GetDatabase(NoSqlHelper.GetClient(connectionString), databaseName, databaseSettings);
						NoSqlHelper.Databases.TryAdd(key, database);
					}
				}
			return database;
		}

		/// <summary>
		/// Starts a client session of this database
		/// </summary>
		/// <param name="database"></param>
		/// <param name="options"></param>
		/// <returns></returns>
		public static IClientSessionHandle StartSession(this IMongoDatabase database, ClientSessionOptions options = null)
			=> database.Client.StartSession(options);

		/// <summary>
		/// Starts a client session of this database
		/// </summary>
		/// <param name="database"></param>
		/// <param name="options"></param>
		/// <param name="cancellationToken"></param>
		/// <returns></returns>
		public static Task<IClientSessionHandle> StartSessionAsync(this IMongoDatabase database, ClientSessionOptions options = null, CancellationToken cancellationToken = default)
			=> database.Client.StartSessionAsync(options, cancellationToken);

		/// <summary>
		/// Checks to see database is belong to a client that is connected to a ReplicaSet or not
		/// </summary>
		/// <param name="database"></param>
		/// <returns></returns>
		public static bool IsReplicaSet(this IMongoDatabase database)
			=> database.Client.IsReplicaSet();

		/// <summary>
		/// Checks to see database is belong to a client that is connected to a ReplicaSet or not
		/// </summary>
		/// <param name="database"></param>
		/// <returns></returns>
		public static Task<bool> IsReplicaSetAsync(this IMongoDatabase database, CancellationToken cancellationToken = default)
			=> database.Client.IsReplicaSetAsync(cancellationToken);
		#endregion

		#region Collection
		internal static ConcurrentDictionary<string, object> Collections { get; } = new ConcurrentDictionary<string, object>();

		static string GetCollectionKey(string connectionString, string databaseName, string collectionName)
			=> collectionName.Trim() + "#" + (databaseName.Trim() + "#" + connectionString.Trim()).ToLower().GetMD5();

		/// <summary>
		/// Gets a collection of MongoDB
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="mongoDatabase"></param>
		/// <param name="collectionName"></param>
		/// <param name="collectionSettings"></param>
		/// <returns></returns>
		public static IMongoCollection<T> GetCollection<T>(IMongoDatabase mongoDatabase, string collectionName, MongoCollectionSettings collectionSettings = null) where T : class
			=> mongoDatabase != null && !string.IsNullOrWhiteSpace(collectionName)
				? mongoDatabase.GetCollection<T>(collectionName, collectionSettings)
				: null;

		/// <summary>
		/// Gets a collection of MongoDB
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="connectionString"></param>
		/// <param name="databaseName"></param>
		/// <param name="collectionName"></param>
		/// <param name="disableCache"></param>
		/// <param name="databaseSettings"></param>
		/// <param name="collectionSettings"></param>
		/// <returns></returns>
		public static IMongoCollection<T> GetCollection<T>(string connectionString, string databaseName, string collectionName, bool disableCache = false, MongoDatabaseSettings databaseSettings = null, MongoCollectionSettings collectionSettings = null) where T : class
		{
			if (string.IsNullOrWhiteSpace(connectionString) || string.IsNullOrWhiteSpace(databaseName) || string.IsNullOrWhiteSpace(collectionName))
				return null;

			if (disableCache)
				return NoSqlHelper.GetCollection<T>(NoSqlHelper.GetDatabase(connectionString, databaseName, databaseSettings), collectionName, collectionSettings);

			var key = GetCollectionKey(connectionString, databaseName, collectionName);
			if (!NoSqlHelper.Collections.TryGetValue(key, out var collection))
				lock (NoSqlHelper.Collections)
				{
					if (!NoSqlHelper.Collections.TryGetValue(key, out collection))
					{
						collection = NoSqlHelper.GetCollection<T>(NoSqlHelper.GetDatabase(connectionString, databaseName, databaseSettings), collectionName, collectionSettings);
						NoSqlHelper.Collections.TryAdd(key, collection);
					}
				}
			return collection as IMongoCollection<T>;
		}

		/// <summary>
		/// Gets a collection in NoSQL database (MongoDB collection)
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="dataSource">The data source</param>
		/// <param name="entityDefinition">The entity definition</param>
		/// <returns></returns>
		public static IMongoCollection<T> GetCollection<T>(this DataSource dataSource, EntityDefinition entityDefinition) where T : class
			=> NoSqlHelper.GetCollection<T>(RepositoryMediator.GetConnectionString(dataSource), dataSource.DatabaseName, entityDefinition.CollectionName);

		/// <summary>
		/// Gets a collection in NoSQL database (MongoDB collection)
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="dataSource">The data source</param>
		/// <returns></returns>
		public static IMongoCollection<T> GetCollection<T>(this DataSource dataSource) where T : class
			=> dataSource.GetCollection<T>(RepositoryMediator.GetEntityDefinition<T>());

		/// <summary>
		/// Gets a collection in NoSQL database (MongoDB collection)
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="context">The working context</param>
		/// <param name="dataSource">The data source</param>
		/// <returns></returns>
		public static IMongoCollection<T> GetCollection<T>(this RepositoryContext context, DataSource dataSource) where T : class
			=> NoSqlHelper.GetCollection<T>(dataSource, context.EntityDefinition);

		/// <summary>
		/// Drops a collection in NoSQL database (MongoDB collection)
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="dataSource">The data source</param>
		/// <param name="entityDefinition">The entity definition</param>
		/// <returns></returns>
		public static bool DropCollection<T>(this DataSource dataSource, EntityDefinition entityDefinition) where T : class
		{
			entityDefinition = entityDefinition ?? RepositoryMediator.GetEntityDefinition<T>();
			var connectionString = RepositoryMediator.GetConnectionString(dataSource);
			var database = NoSqlHelper.GetDatabase(RepositoryMediator.GetConnectionString(dataSource), dataSource.DatabaseName);
			database.DropCollection(entityDefinition.CollectionName);
			return NoSqlHelper.Collections.TryRemove(GetCollectionKey(connectionString, dataSource.DatabaseName, entityDefinition.CollectionName), out var _);
		}

		/// <summary>
		/// Gets a collection in NoSQL database (MongoDB collection)
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="dataSource">The data source</param>
		/// <returns></returns>
		public static bool DropCollection<T>(this DataSource dataSource) where T : class
			=> dataSource.DropCollection<T>(RepositoryMediator.GetEntityDefinition<T>());

		/// <summary>
		/// Gets a collection in NoSQL database (MongoDB collection)
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <returns></returns>
		public static bool DropCollection<T>() where T : class
		{
			var entityDefinition = RepositoryMediator.GetEntityDefinition<T>();
			var dataSource = entityDefinition.GetPrimaryDataSource();
			return dataSource != null && dataSource.DropCollection<T>(entityDefinition);
		}

		/// <summary>
		/// Drops a collection in NoSQL database (MongoDB collection)
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="dataSource">The data source</param>
		/// <param name="entityDefinition">The entity definition</param>
		/// <param name="cancellationToken"></param>
		/// <returns></returns>
		public static async Task<bool> DropCollectionAsync<T>(this DataSource dataSource, EntityDefinition entityDefinition, CancellationToken cancellationToken = default) where T : class
		{
			entityDefinition = entityDefinition ?? RepositoryMediator.GetEntityDefinition<T>();
			var connectionString = RepositoryMediator.GetConnectionString(dataSource);
			var database = NoSqlHelper.GetDatabase(RepositoryMediator.GetConnectionString(dataSource), dataSource.DatabaseName);
			await database.DropCollectionAsync(entityDefinition.CollectionName, cancellationToken).ConfigureAwait(false);
			return NoSqlHelper.Collections.TryRemove(GetCollectionKey(connectionString, dataSource.DatabaseName, entityDefinition.CollectionName), out var _);
		}

		/// <summary>
		/// Gets a collection in NoSQL database (MongoDB collection)
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="dataSource">The data source</param>
		/// <param name="cancellationToken"></param>
		/// <returns></returns>
		public static Task<bool> DropCollectionAsync<T>(this DataSource dataSource, CancellationToken cancellationToken = default) where T : class
			=> dataSource.DropCollectionAsync<T>(RepositoryMediator.GetEntityDefinition<T>());

		/// <summary>
		/// Gets a collection in NoSQL database (MongoDB collection)
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="cancellationToken"></param>
		/// <returns></returns>
		public static Task<bool> DropCollectionAsync<T>(CancellationToken cancellationToken = default) where T : class
		{
			var entityDefinition = RepositoryMediator.GetEntityDefinition<T>();
			var dataSource = entityDefinition.GetPrimaryDataSource();
			return dataSource != null ? dataSource.DropCollectionAsync<T>(entityDefinition) : Task.FromResult<bool>(false);
		}

		/// <summary>
		/// Starts a client session of this collection
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="options"></param>
		/// <returns></returns>
		public static IClientSessionHandle StartSession<T>(this IMongoCollection<T> collection, ClientSessionOptions options = null) where T : class
			=> collection.Database.StartSession(options);

		/// <summary>
		/// Starts a client session of this collection
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="options"></param>
		/// <param name="cancellationToken"></param>
		/// <returns></returns>
		public static Task<IClientSessionHandle> StartSessionAsync<T>(this IMongoCollection<T> collection, ClientSessionOptions options = null, CancellationToken cancellationToken = default) where T : class
			=> collection.Database.StartSessionAsync(options, cancellationToken);

		/// <summary>
		/// Starts a client session of this collection
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="cancellationToken"></param>
		/// <returns></returns>
		public static Task<IClientSessionHandle> StartSessionAsync<T>(this IMongoCollection<T> collection, CancellationToken cancellationToken) where T : class
			=> collection.Database.StartSessionAsync(null, cancellationToken);

		/// <summary>
		/// Checks to see collection is belong to a client that is connected to a ReplicaSet or not
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <returns></returns>
		public static bool IsReplicaSet<T>(this IMongoCollection<T> collection)
			=> collection.Database.IsReplicaSet();

		/// <summary>
		/// Checks to see collection is belong to a client that is connected to a ReplicaSet or not
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <returns></returns>
		public static Task<bool> IsReplicaSetAsync<T>(this IMongoCollection<T> collection, CancellationToken cancellationToken = default)
			=> collection.Database.IsReplicaSetAsync(cancellationToken);
		#endregion

		#region Helpers (filter, sort, projection, find fluent)
		static FilterDefinition<T> CreateFilterDefinition<T>(this string query) where T : class
		{
			var searchTerms = "";
			var searchQuery = new SearchQuery(query);
			searchQuery.AndWords.ForEach(word => searchTerms += (!searchTerms.Equals("") ? " " : "") + word);
			searchQuery.OrWords.ForEach(word => searchTerms += (!searchTerms.Equals("") ? " " : "") + word);
			searchQuery.NotWords.ForEach(word => searchTerms += (!searchTerms.Equals("") ? " " : "") + "-" + word);
			searchQuery.AndPhrases.ForEach(phrase => searchTerms += (!searchTerms.Equals("") ? " " : "") + $"\"{phrase}\"");
			searchQuery.OrPhrases.ForEach(phrase => searchTerms += (!searchTerms.Equals("") ? " " : "") + $"\"{phrase}\"");
			searchQuery.NotPhrases.ForEach(phrase => searchTerms += (!searchTerms.Equals("") ? " " : "") + "-" + $"\"{phrase}\"");
			return Builders<T>.Filter.Text(searchTerms, new TextSearchOptions { CaseSensitive = false });
		}

		static FilterDefinition<T> CreateFilterDefinition<T>(this IFilterBy<T> filter, string businessRepositoryEntityID = null) where T : class
		{
			var(standardProperties, extendedProperties) = RepositoryMediator.GetProperties<T>(businessRepositoryEntityID);
			var filterDefinition = filter != null
				? filter is FilterBys<T>
					? (filter as FilterBys<T>).GetNoSqlStatement(standardProperties, extendedProperties)
					: (filter as FilterBy<T>).GetNoSqlStatement(standardProperties, extendedProperties)
				: null;
			if (!string.IsNullOrWhiteSpace(businessRepositoryEntityID) && extendedProperties != null)
				filterDefinition = filterDefinition == null
					? Builders<T>.Filter.Eq("RepositoryEntityID", businessRepositoryEntityID)
					: filterDefinition & Builders<T>.Filter.Eq("RepositoryEntityID", businessRepositoryEntityID);
			return filterDefinition;
		}

		static SortDefinition<T> CreateSortDefinition<T>(this SortBy<T> sort, string businessRepositoryEntityID = null) where T : class
		{
			if (sort == null)
				return null;
			var propertiesInfo = RepositoryMediator.GetProperties<T>(businessRepositoryEntityID);
			var standardProperties = propertiesInfo.Item1;
			var extendedProperties = propertiesInfo.Item2;
			return sort.GetNoSqlStatement(null, standardProperties, extendedProperties);
		}

		static SortDefinition<T> CreateSortDefinition<T>(this string scoreProperty) where T : class
			=> Builders<T>.Sort.MetaTextScore(scoreProperty ?? "SearchScore");

		static SortDefinition<T> CreateSortDefinition<T>(this SortDefinition<T> sort, string scoreProperty) where T : class
			=> sort != null
				? sort.MetaTextScore(scoreProperty ?? "SearchScore")
				: NoSqlHelper.CreateSortDefinition<T>(scoreProperty);

		static ProjectionDefinition<T> CreateProjectionDefinition<T>(this IEnumerable<string> attributes) where T : class
		{
			ProjectionDefinition<T> projection = null;
			if (attributes == null || !attributes.Any())
				projection = Builders<T>.Projection.Include("_id");
			else
				attributes.ForEach(attribute => projection = projection == null ? Builders<T>.Projection.Include(attribute) : projection.Include(attribute));
			return projection;
		}

		static ProjectionDefinition<T> CreateProjectionDefinition<T>(this string scoreProperty) where T : class
			=> Builders<T>.Projection.MetaTextScore(scoreProperty ?? "SearchScore");

		static ProjectionDefinition<T> CreateProjectionDefinition<T>(this IEnumerable<string> attributes, string scoreProperty) where T : class
			=> attributes != null && attributes.Any()
				? NoSqlHelper.CreateProjectionDefinition<T>(attributes).MetaTextScore(scoreProperty ?? "SearchScore")
				: NoSqlHelper.CreateProjectionDefinition<T>(scoreProperty);

		static IFindFluent<T, T> CreateFindFluent<T>(this IMongoCollection<T> collection, IClientSessionHandle session, FilterDefinition<T> filter, SortDefinition<T> sort, int pageSize, int pageNumber, FindOptions options = null) where T : class
		{
			if (options == null)
			{
				options = new FindOptions();
				if (!string.IsNullOrWhiteSpace(NoSqlHelper.AllowDiskUse) && !"(null)".IsEquals(NoSqlHelper.AllowDiskUse))
					options.AllowDiskUse = "true".IsEquals(NoSqlHelper.AllowDiskUse);
				if (!string.IsNullOrWhiteSpace(NoSqlHelper.AllowPartialResults) && !"(null)".IsEquals(NoSqlHelper.AllowPartialResults))
					options.AllowPartialResults = "true".IsEquals(NoSqlHelper.AllowPartialResults);
			}
			var findFluent = collection.Find(session, filter ?? Builders<T>.Filter.Empty, options).Sort(sort ?? Builders<T>.Sort.Ascending("_id"));
			if (pageSize > 0)
			{
				if (pageNumber > 1)
					findFluent = findFluent.Skip((pageNumber - 1) * pageSize);
				findFluent = findFluent.Limit(pageSize);
			}
			return findFluent;
		}

		static IFindFluent<T, BsonDocument> CreateSelectFluent<T>(this IMongoCollection<T> collection, IClientSessionHandle session, IEnumerable<string> attributes, FilterDefinition<T> filter, SortDefinition<T> sort, int pageSize, int pageNumber, FindOptions options = null) where T : class
			=> collection.CreateFindFluent(session, filter, sort, pageSize, pageNumber, options).Project(NoSqlHelper.CreateProjectionDefinition<T>(attributes));

		static IFindFluent<T, T> CreateSearchFluent<T>(this IMongoCollection<T> collection, IClientSessionHandle session, string query, FilterDefinition<T> filter, SortDefinition<T> sort, string scoreProperty, IEnumerable<string> attributes, int pageSize, int pageNumber, FindOptions options = null) where T : class
		{
			var filterBy = filter != null && !filter.Equals(Builders<T>.Filter.Empty)
				? query.CreateFilterDefinition<T>() & filter
				: query.CreateFilterDefinition<T>();
			var sortBy = NoSqlHelper.CreateSortDefinition<T>(sort, scoreProperty);
			var projection = NoSqlHelper.CreateProjectionDefinition<T>(attributes, scoreProperty);
			return collection.CreateFindFluent(session, filterBy, sortBy, pageSize, pageNumber, options).Project<T>(projection);
		}

		static BsonDocument Render<T>(this FilterDefinition<T> filter) where T : class
		{
			var serializerRegistry = BsonSerializer.SerializerRegistry;
			var documentSerializer = serializerRegistry.GetSerializer<T>();
			return filter.Render(new RenderArgs<T>(documentSerializer, serializerRegistry));
		}
		#endregion

		#region Create
		/// <summary>
		/// Creates new document of an object
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="session">The working session</param>
		/// <param name="object"></param>
		/// <param name="options"></param>
		public static void Create<T>(this IMongoCollection<T> collection, IClientSessionHandle session, T @object, InsertOneOptions options = null) where T : class
		{
			if (@object == null)
				throw new ArgumentNullException(nameof(@object), "The object is null");

			var stopwatch = Stopwatch.StartNew();
			collection.InsertOne(session ?? collection.StartSession(), @object, options);
			stopwatch.Stop();
			if (RepositoryMediator.IsDebugEnabled)
				RepositoryMediator.WriteLogs(new[]
				{
					$"NoSQL: Perform CREATE command successful [{typeof(T)}#{@object?.GetEntityID()}] @ {collection.CollectionNamespace.CollectionName}",
					$"{(@object != null ? "Objects' data:\r\n\t" + @object.GetPublicProperties(attribute => !attribute.IsIgnored()).Select(attribute => $"+ @{attribute.Name} ({attribute.Type.GetTypeName(true)}) => [{@object.GetAttributeValue(attribute) ?? "(null)"}]").ToString("\r\n\t") + "\r\n" : "")}Execution times: {stopwatch.GetElapsedTimes()}"
				});
		}

		/// <summary>
		/// Creates new document of an object
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="object"></param>
		/// <param name="options"></param>
		public static void Create<T>(this IMongoCollection<T> collection, T @object, InsertOneOptions options = null) where T : class
			=> collection.Create(null, @object, options);

		/// <summary>
		/// Creates new document of an object
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="dataSource">The data source</param>
		/// <param name="object">The object for creating new instance in storage</param>
		/// <param name="options"></param>
		public static void Create<T>(DataSource dataSource, T @object, InsertOneOptions options = null) where T : class
			=> NoSqlHelper.GetCollection<T>(dataSource, RepositoryMediator.GetEntityDefinition<T>()).Create(@object, options);

		/// <summary>
		/// Creates new document of an object
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="object">The object for creating new instance in storage</param>
		/// <param name="options"></param>
		public static void Create<T>(T @object, InsertOneOptions options = null) where T : class
			=> NoSqlHelper.Create(RepositoryMediator.GetEntityDefinition<T>().GetPrimaryDataSource(), @object, options);

		/// <summary>
		/// Creates new document of an object
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="context">The working context</param>
		/// <param name="dataSource">The data source</param>
		/// <param name="object">The object for creating new instance in storage</param>
		/// <param name="options"></param>
		public static void Create<T>(this RepositoryContext context, DataSource dataSource, T @object, InsertOneOptions options = null) where T : class
			=> context.GetCollection<T>(dataSource).Create(context.NoSqlSession, @object, options);

		/// <summary>
		/// Creates new document of an object
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="session">The working session</param>
		/// <param name="object"></param>
		/// <param name="options"></param>
		/// <param name="cancellationToken"></param>
		/// <returns></returns>
		public static async Task CreateAsync<T>(this IMongoCollection<T> collection, IClientSessionHandle session, T @object, InsertOneOptions options = null, CancellationToken cancellationToken = default) where T : class
		{
			if (@object == null)
				throw new ArgumentNullException(nameof(@object), "The object is null");

			var stopwatch = Stopwatch.StartNew();
			await collection.InsertOneAsync(session ?? await collection.StartSessionAsync(cancellationToken).ConfigureAwait(false), @object, options, cancellationToken).ConfigureAwait(false);
			stopwatch.Stop();
			if (RepositoryMediator.IsDebugEnabled)
				RepositoryMediator.WriteLogs(new[]
				{
					$"NoSQL: Perform CREATE command successful [{typeof(T)}#{@object?.GetEntityID()}] @ {collection.CollectionNamespace.CollectionName}",
					$"{(@object != null ? "Objects' data:\r\n\t" + @object.GetPublicProperties(attribute => !attribute.IsIgnored()).Select(attribute => $"+ @{attribute.Name} ({attribute.Type.GetTypeName(true)}) => [{@object.GetAttributeValue(attribute) ?? "(null)"}]").ToString("\r\n\t") + "\r\n" : "")}Execution times: {stopwatch.GetElapsedTimes()}"
				});
		}

		/// <summary>
		/// Creates new document of an object
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="object"></param>
		/// <param name="options"></param>
		/// <param name="cancellationToken"></param>
		/// <returns></returns>
		public static Task CreateAsync<T>(this IMongoCollection<T> collection, T @object, InsertOneOptions options = null, CancellationToken cancellationToken = default) where T : class
			=> collection.CreateAsync(null, @object, options, cancellationToken);

		/// <summary>
		/// Creates new document of an object
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="dataSource">The data source</param>
		/// <param name="object">The object for creating new instance in storage</param>
		/// <param name="options"></param>
		public static Task CreateAsync<T>(DataSource dataSource, T @object, InsertOneOptions options = null, CancellationToken cancellationToken = default) where T : class
			=> NoSqlHelper.GetCollection<T>(dataSource, RepositoryMediator.GetEntityDefinition<T>()).CreateAsync(@object, options, cancellationToken);

		/// <summary>
		/// Creates new document of an object
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="object">The object for creating new instance in storage</param>
		/// <param name="options"></param>
		public static Task CreateAsync<T>(T @object, InsertOneOptions options = null, CancellationToken cancellationToken = default) where T : class
			=> NoSqlHelper.CreateAsync(RepositoryMediator.GetEntityDefinition<T>().GetPrimaryDataSource(), @object, options, cancellationToken);

		/// <summary>
		/// Creates new document of an object
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="context">The working context</param>
		/// <param name="dataSource">The data source</param>
		/// <param name="object">The object for creating new instance in storage</param>
		/// <param name="options"></param>
		/// <param name="cancellationToken"></param>
		public static Task CreateAsync<T>(this RepositoryContext context, DataSource dataSource, T @object, InsertOneOptions options = null, CancellationToken cancellationToken = default) where T : class
			=> context.GetCollection<T>(dataSource).CreateAsync(context.NoSqlSession, @object, options, cancellationToken);
		#endregion

		#region Create (many)
		/// <summary>
		/// Creates new document of collection of objects
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="session">The working session</param>
		/// <param name="objects"></param>
		/// <param name="options"></param>
		public static void CreateMany<T>(this IMongoCollection<T> collection, IClientSessionHandle session, IEnumerable<T> objects, InsertManyOptions options = null) where T : class
		{
			if (objects == null)
				throw new ArgumentNullException(nameof(objects), "The objects are null");

			var stopwatch = Stopwatch.StartNew();
			if (session != null)
				collection.InsertMany(session, objects, options);
			else
				collection.InsertMany(objects, options);
			stopwatch.Stop();
			if (RepositoryMediator.IsDebugEnabled)
				RepositoryMediator.WriteLogs(new[]
				{
					$"NoSQL: Perform CREATE command on multiple objects successful [{typeof(T)}] @ {collection.CollectionNamespace.CollectionName}",
					$"{(objects != null ? "Objects' IDs: " + objects.Select(@object => @object.GetEntityID()).Join(" - ") + "\r\n" : "")}Execution times: {stopwatch.GetElapsedTimes()}"
				});
		}

		/// <summary>
		/// Creates new document of collection of objects
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="objects"></param>
		/// <param name="options"></param>
		public static void CreateMany<T>(this IMongoCollection<T> collection, IEnumerable<T> objects, InsertManyOptions options = null) where T : class
			=> collection.CreateMany(null, objects, options);

		/// <summary>
		/// Creates new document of collection of objects
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="dataSource">The data source</param>
		/// <param name="objects">The collection of objects for creating new instance in storage</param>
		/// <param name="options"></param>
		public static void CreateMany<T>(DataSource dataSource, IEnumerable<T> objects, InsertManyOptions options = null) where T : class
			=> NoSqlHelper.GetCollection<T>(dataSource, RepositoryMediator.GetEntityDefinition<T>()).CreateMany(objects, options);

		/// <summary>
		/// Creates new document of collection of objects
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="objects">The collection of objects for creating new instance in storage</param>
		/// <param name="options"></param>
		public static void CreateMany<T>(IEnumerable<T> objects, InsertManyOptions options = null) where T : class
			=> NoSqlHelper.CreateMany(RepositoryMediator.GetEntityDefinition<T>().GetPrimaryDataSource(), objects, options);

		/// <summary>
		/// Creates new document of collection of objects
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="context">The working context</param>
		/// <param name="dataSource">The data source</param>
		/// <param name="objects">The object for creating new instance in storage</param>
		/// <param name="options"></param>
		public static void CreateMany<T>(this RepositoryContext context, DataSource dataSource, IEnumerable<T> objects, InsertManyOptions options = null) where T : class
			=> context.GetCollection<T>(dataSource).CreateMany(context.NoSqlSession, objects, options);

		/// <summary>
		/// Creates new document of collection of objects
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="session">The working session</param>
		/// <param name="objects">The collection of objects for creating new instance in storage</param>
		/// <param name="options"></param>
		/// <param name="cancellationToken"></param>
		/// <returns></returns>
		public static async Task CreateManyAsync<T>(this IMongoCollection<T> collection, IClientSessionHandle session, IEnumerable<T> objects, InsertManyOptions options = null, CancellationToken cancellationToken = default) where T : class
		{
			if (objects == null)
				throw new ArgumentNullException(nameof(objects), "The objects are null");

			var stopwatch = Stopwatch.StartNew();
			await (session != null ? collection.InsertManyAsync(session, objects, options, cancellationToken) : collection.InsertManyAsync(objects, options, cancellationToken)).ConfigureAwait(false);
			stopwatch.Stop();
			if (RepositoryMediator.IsDebugEnabled)
				RepositoryMediator.WriteLogs(new[]
				{
					$"NoSQL: Perform CREATE command on multiple objects successful [{typeof(T)}] @ {collection.CollectionNamespace.CollectionName}",
					$"{(objects != null ? "Objects' IDs: " + objects.Select(@object => @object.GetEntityID()).Join(" - ") + "\r\n" : "")}Execution times: {stopwatch.GetElapsedTimes()}"
				});
		}

		/// <summary>
		/// Creates new document of collection of objects
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="objects"></param>
		/// <param name="options"></param>
		/// <param name="cancellationToken"></param>
		/// <returns></returns>
		public static Task CreateManyAsync<T>(this IMongoCollection<T> collection, IEnumerable<T> objects, InsertManyOptions options = null, CancellationToken cancellationToken = default) where T : class
			=> collection.CreateManyAsync(null, objects, options, cancellationToken);

		/// <summary>
		/// Creates new document of collection of objects
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="dataSource">The data source</param>
		/// <param name="objects">The collection of objects for creating new instance in storage</param>
		/// <param name="options"></param>
		public static Task CreateManyAsync<T>(DataSource dataSource, IEnumerable<T> objects, InsertManyOptions options = null, CancellationToken cancellationToken = default) where T : class
			=> NoSqlHelper.GetCollection<T>(dataSource, RepositoryMediator.GetEntityDefinition<T>()).CreateManyAsync(objects, options, cancellationToken);

		/// <summary>
		/// Creates new document of collection of objects
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="objects">The collection of objects for creating new instance in storage</param>
		/// <param name="options"></param>
		public static Task CreateManyAsync<T>(IEnumerable<T> objects, InsertManyOptions options = null, CancellationToken cancellationToken = default) where T : class
			=> NoSqlHelper.CreateManyAsync(RepositoryMediator.GetEntityDefinition<T>().GetPrimaryDataSource(), objects, options, cancellationToken);

		/// <summary>
		/// Creates new document of collection of objects
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="context">The working context</param>
		/// <param name="dataSource">The data source</param>
		/// <param name="objects">The collection of objects for creating new instance in storage</param>
		/// <param name="options"></param>
		/// <param name="cancellationToken"></param>
		public static Task CreateManyAsync<T>(this RepositoryContext context, DataSource dataSource, IEnumerable<T> objects, InsertManyOptions options = null, CancellationToken cancellationToken = default) where T : class
			=> context.GetCollection<T>(dataSource).CreateManyAsync(context.NoSqlSession, objects, options, cancellationToken);
		#endregion

		#region Get
		/// <summary>
		/// Gets document of an object
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="session">The working session</param>
		/// <param name="id"></param>
		/// <param name="options">The options</param>
		/// <returns></returns>
		public static T Get<T>(this IMongoCollection<T> collection, IClientSessionHandle session, string id, FindOptions options = null) where T : class
			=> !string.IsNullOrWhiteSpace(id)
				? collection.Get(session, Builders<T>.Filter.Eq("_id", id), null, options)
				: default;

		/// <summary>
		/// Gets document of an object
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="id"></param>
		/// <param name="options">The options</param>
		/// <returns></returns>
		public static T Get<T>(this IMongoCollection<T> collection, string id, FindOptions options = null) where T : class
			=> collection.Get(null, id, options);

		/// <summary>
		/// Gets document of an object
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="context">The working context</param>
		/// <param name="dataSource">The data source</param>
		/// <param name="id">The string that presents identity</param>
		/// <param name="options">The options</param>
		/// <returns></returns>
		public static T Get<T>(this RepositoryContext context, DataSource dataSource, string id, FindOptions options = null) where T : class
			=> !string.IsNullOrWhiteSpace(id)
				? context.GetCollection<T>(dataSource).Get(context.NoSqlSession, id, options)
				: default;

		/// <summary>
		/// Gets document of an object
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="session">The working session</param>
		/// <param name="id">The string that presents identity of the object that need to get</param>
		/// <param name="options">The options</param>
		/// <param name="cancellationToken">The cancellation token</param>
		/// <returns></returns>
		public static Task<T> GetAsync<T>(this IMongoCollection<T> collection, IClientSessionHandle session, string id, FindOptions options = null, CancellationToken cancellationToken = default) where T : class
			=> !string.IsNullOrWhiteSpace(id)
				? collection.GetAsync(session, Builders<T>.Filter.Eq("_id", id), null, options, cancellationToken)
				: Task.FromResult(default(T));

		/// <summary>
		/// Gets document of an object
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="id">The string that presents identity of the object that need to get</param>
		/// <param name="options">The options</param>
		/// <param name="cancellationToken">The cancellation token</param>
		/// <returns></returns>
		public static Task<T> GetAsync<T>(this IMongoCollection<T> collection, string id, FindOptions options = null, CancellationToken cancellationToken = default) where T : class
			=> collection.GetAsync(null, id, options, cancellationToken);

		/// <summary>
		/// Gets document of an object
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="context">The working context</param>
		/// <param name="dataSource">The data source</param>
		/// <param name="id">The string that presents identity of the object that need to get</param>
		/// <param name="options">The options</param>
		/// <param name="cancellationToken">The cancellation token</param>
		/// <returns></returns>
		public static Task<T> GetAsync<T>(this RepositoryContext context, DataSource dataSource, string id, FindOptions options = null, CancellationToken cancellationToken = default) where T : class
			=> context.GetCollection<T>(dataSource).GetAsync(context.NoSqlSession, id, options, cancellationToken);
		#endregion

		#region Get (first match)
		/// <summary>
		/// Gets document of an object
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="session">The working session</param>
		/// <param name="filter">The filter-by expression for filtering</param>
		/// <param name="sort">The order-by expression for ordering</param>
		/// <param name="options">The options</param>
		/// <returns></returns>
		public static T Get<T>(this IMongoCollection<T> collection, IClientSessionHandle session, FilterDefinition<T> filter, SortDefinition<T> sort = null, FindOptions options = null) where T : class
			=> collection.Find(session, filter, sort, 1, 1, options).First();

		/// <summary>
		/// Gets document of an object
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="filter">The filter-by expression for filtering</param>
		/// <param name="sort">The order-by expression for ordering</param>
		/// <param name="options">The options</param>
		/// <returns></returns>
		public static T Get<T>(this IMongoCollection<T> collection, FilterDefinition<T> filter, SortDefinition<T> sort = null, FindOptions options = null) where T : class
			=> collection.Get(null, filter, sort, options);

		/// <summary>
		/// Gets document of an object
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="context">The working context</param>
		/// <param name="dataSource">The data source</param>
		/// <param name="filter">The filter-by expression for filtering</param>
		/// <param name="sort">The order-by expression for ordering</param>
		/// <param name="businessRepositoryEntityID">The identity of a business repository entity for working with extended properties/seperated data of a business content-type</param>
		/// <param name="options">The options</param>
		/// <returns></returns>
		public static T Get<T>(this RepositoryContext context, DataSource dataSource, IFilterBy<T> filter, SortBy<T> sort = null, string businessRepositoryEntityID = null, FindOptions options = null) where T : class
			=> context.GetCollection<T>(dataSource).Get(context.NoSqlSession, NoSqlHelper.CreateFilterDefinition<T>(filter, businessRepositoryEntityID), NoSqlHelper.CreateSortDefinition<T>(sort, businessRepositoryEntityID), options);

		/// <summary>
		/// Gets document of an object
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="session">The working session</param>
		/// <param name="filter">The filter-by expression for filtering</param>
		/// <param name="sort">The order-by expression for ordering</param>
		/// <param name="options">The options</param>
		/// <param name="cancellationToken">The cancellation token</param>
		/// <returns></returns>
		public static async Task<T> GetAsync<T>(this IMongoCollection<T> collection, IClientSessionHandle session, FilterDefinition<T> filter, SortDefinition<T> sort = null, FindOptions options = null, CancellationToken cancellationToken = default) where T : class
			=> (await collection.FindAsync(session, filter, sort, 1, 1, options, cancellationToken).ConfigureAwait(false)).First();

		/// <summary>
		/// Gets document of an object
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="filter">The filter-by expression for filtering</param>
		/// <param name="sort">The order-by expression for ordering</param>
		/// <param name="options">The options</param>
		/// <param name="cancellationToken">The cancellation token</param>
		/// <returns></returns>
		public static Task<T> GetAsync<T>(this IMongoCollection<T> collection, FilterDefinition<T> filter, SortDefinition<T> sort = null, FindOptions options = null, CancellationToken cancellationToken = default) where T : class
			=> collection.GetAsync(null, filter, sort, options, cancellationToken);

		/// <summary>
		/// Gets document of an object
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="context">The working context</param>
		/// <param name="dataSource">The data source</param>
		/// <param name="filter">The filter-by expression for filtering</param>
		/// <param name="sort">The order-by expression for ordering</param>
		/// <param name="businessRepositoryEntityID">The identity of a business repository entity for working with extended properties/seperated data of a business content-type</param>
		/// <param name="options">The options</param>
		/// <param name="cancellationToken">The cancellation token</param>
		/// <returns></returns>
		public static Task<T> GetAsync<T>(this RepositoryContext context, DataSource dataSource, IFilterBy<T> filter, SortBy<T> sort = null, string businessRepositoryEntityID = null, FindOptions options = null, CancellationToken cancellationToken = default) where T : class
			=> context.GetCollection<T>(dataSource).GetAsync(context.NoSqlSession, NoSqlHelper.CreateFilterDefinition<T>(filter, businessRepositoryEntityID), NoSqlHelper.CreateSortDefinition<T>(sort, businessRepositoryEntityID), options, cancellationToken);
		#endregion

		#region Get (by definition and identity)
		/// <summary>
		/// Gets document of an object
		/// </summary>
		/// <param name="dataSource">The data source</param>
		/// <param name="definition">The definition</param>
		/// <param name="id">The identity</param>
		/// <param name="options">The options</param>
		/// <returns></returns>
		public static object Get(DataSource dataSource, EntityDefinition definition, string id, FindOptions options = null)
		{
			dataSource = dataSource ?? definition.GetPrimaryDataSource();
			var collection = NoSqlHelper.GetCollection<BsonDocument>(RepositoryMediator.GetConnectionString(dataSource), dataSource.DatabaseName, definition.CollectionName, true);
			var document = collection.Get(id, options);
			return document != null
				? BsonSerializer.Deserialize(document, definition.Type)
				: null;
		}

		/// <summary>
		/// Gets document of an object
		/// </summary>
		/// <param name="definition">The definition</param>
		/// <param name="id">The identity</param>
		/// <param name="options">The options</param>
		/// <returns></returns>
		public static object Get(EntityDefinition definition, string id, FindOptions options = null)
			=> NoSqlHelper.Get(definition?.GetPrimaryDataSource(), definition, id, options);

		/// <summary>
		/// Gets document of an object
		/// </summary>
		/// <param name="dataSource">The data source</param>
		/// <param name="definition">The definition</param>
		/// <param name="id">The identity</param>
		/// <param name="options">The options</param>
		/// <param name="cancellationToken">The cancellation token</param>
		/// <returns></returns>
		public static async Task<object> GetAsync(DataSource dataSource, EntityDefinition definition, string id, FindOptions options = null, CancellationToken cancellationToken = default)
		{
			dataSource = dataSource ?? definition.GetPrimaryDataSource();
			var collection = NoSqlHelper.GetCollection<BsonDocument>(RepositoryMediator.GetConnectionString(dataSource), dataSource.DatabaseName, definition.CollectionName, true);
			var document = await collection.GetAsync(id, options, cancellationToken).ConfigureAwait(false);
			return document != null
				? BsonSerializer.Deserialize(document, definition.Type)
				: null;
		}

		/// <summary>
		/// Gets document of an object
		/// </summary>
		/// <param name="definition">The definition</param>
		/// <param name="id">The identity</param>
		/// <param name="options">The options</param>
		/// <param name="cancellationToken">The cancellation token</param>
		/// <returns></returns>
		public static Task<object> GetAsync(EntityDefinition definition, string id, FindOptions options = null, CancellationToken cancellationToken = default)
			=> NoSqlHelper.GetAsync(definition?.GetPrimaryDataSource(), definition, id, options, cancellationToken);
		#endregion

		#region Replace
		/// <summary>
		/// Replaces document of an object
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="session">The working session</param>
		/// <param name="object">The object for updating</param>
		/// <param name="options">The options for updating</param>
		/// <returns></returns>
		public static ReplaceOneResult Replace<T>(this IMongoCollection<T> collection, IClientSessionHandle session, T @object, ReplaceOptions options = null) where T : class
		{
			var stopwatch = Stopwatch.StartNew();
			try
			{
				return @object != null
					? collection.ReplaceOne(session ?? collection.StartSession(), Builders<T>.Filter.Eq("_id", @object.GetEntityID()), @object, options ?? new ReplaceOptions { IsUpsert = true })
					: throw new ArgumentNullException(nameof(@object), "The object is null");
			}
			catch (Exception)
			{
				throw;
			}
			finally
			{
				stopwatch.Stop();
				if (RepositoryMediator.IsDebugEnabled)
					RepositoryMediator.WriteLogs(new[]
					{
						$"NoSQL: {(@object != null ? "Perform REPLACE command successful" : "No valid object to perform replace")} [{typeof(T)}#{@object?.GetEntityID()}] @ {collection.CollectionNamespace.CollectionName}",
						$"{(@object != null ? "Objects' data:\r\n\t" + @object.GetPublicProperties(attribute => !attribute.IsIgnored()).Select(attribute => $"+ @{attribute.Name} ({attribute.Type.GetTypeName(true)}) => [{@object.GetAttributeValue(attribute) ?? "(null)"}]").ToString("\r\n\t") + "\r\n" : "")}Execution times: {stopwatch.GetElapsedTimes()}"
					});
			}
		}

		/// <summary>
		/// Replaces document of an object
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="object">The object for updating</param>
		/// <param name="options">The options for updating</param>
		/// <returns></returns>
		public static ReplaceOneResult Replace<T>(this IMongoCollection<T> collection, T @object, ReplaceOptions options = null) where T : class
			=> collection.Replace(null, @object, options);

		/// <summary>
		/// Replaces document of an object
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="context">The working context</param>
		/// <param name="dataSource">The data source</param>
		/// <param name="object">The object for updating</param>
		/// <param name="options">The options for updating</param>
		/// <returns></returns>
		public static ReplaceOneResult Replace<T>(this RepositoryContext context, DataSource dataSource, T @object, ReplaceOptions options = null) where T : class
			=> context.GetCollection<T>(dataSource).Replace(context.NoSqlSession, @object, options);

		/// <summary>
		/// Replaces document of an object
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="session">The working session</param>
		/// <param name="object">The object for updating</param>
		/// <param name="options">The options for updating</param>
		/// <param name="cancellationToken">The cancellation token</param>
		/// <returns></returns>
		public static async Task<ReplaceOneResult> ReplaceAsync<T>(this IMongoCollection<T> collection, IClientSessionHandle session, T @object, ReplaceOptions options = null, CancellationToken cancellationToken = default) where T : class
		{
			var stopwatch = Stopwatch.StartNew();
			try
			{
				return @object != null
					? await collection.ReplaceOneAsync(session ?? await collection.StartSessionAsync(cancellationToken).ConfigureAwait(false), Builders<T>.Filter.Eq("_id", @object.GetEntityID()), @object, options ?? new ReplaceOptions { IsUpsert = true }, cancellationToken).ConfigureAwait(false)
					: throw new ArgumentNullException(nameof(@object), "The object is null");
			}
			catch (Exception)
			{
				throw;
			}
			finally
			{
				stopwatch.Stop();
				if (RepositoryMediator.IsDebugEnabled)
					RepositoryMediator.WriteLogs(new[]
					{
						$"NoSQL: {(@object != null ? "Perform REPLACE command successful" : "No valid object to perform replace")} [{typeof(T)}#{@object?.GetEntityID()}] @ {collection.CollectionNamespace.CollectionName}",
						$"{(@object != null ? "Objects' data:\r\n\t" + @object.GetPublicProperties(attribute => !attribute.IsIgnored()).Select(attribute => $"+ @{attribute.Name} ({attribute.Type.GetTypeName(true)}) => [{@object.GetAttributeValue(attribute) ?? "(null)"}]").ToString("\r\n\t") + "\r\n" : "")}Execution times: {stopwatch.GetElapsedTimes()}"
					});
			}
		}

		/// <summary>
		/// Replaces document of an object
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="object">The object for updating</param>
		/// <param name="options">The options for updating</param>
		/// <param name="cancellationToken">The cancellation token</param>
		/// <returns></returns>
		public static Task<ReplaceOneResult> ReplaceAsync<T>(this IMongoCollection<T> collection, T @object, ReplaceOptions options = null, CancellationToken cancellationToken = default) where T : class
			=> collection.ReplaceAsync(null, @object, options, cancellationToken);

		/// <summary>
		/// Replaces document of an object
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="context">The working context</param>
		/// <param name="dataSource">The data source</param>
		/// <param name="object">The object for updating</param>
		/// <param name="options">The options for updating</param>
		/// <param name="cancellationToken">The cancellation token</param>
		/// <returns></returns>
		public static Task<ReplaceOneResult> ReplaceAsync<T>(this RepositoryContext context, DataSource dataSource, T @object, ReplaceOptions options = null, CancellationToken cancellationToken = default) where T : class
				=> context.GetCollection<T>(dataSource).ReplaceAsync(context.NoSqlSession, @object, options, cancellationToken);
		#endregion

		#region Update
		static BsonArray ToBsonArray(this IEnumerable @object, Type type)
		{
			var values = new List<BsonValue>();
			if (type.IsClassType())
				foreach (var item in @object)
					if (item == null)
						values.Add(BsonNull.Value);
					else
					{
						var document = item.ToBsonDocument();
						document.Remove("_t");
						values.Add(document);
					}
			else
				foreach (var item in @object)
					values.Add(item == null ? BsonNull.Value : BsonValue.Create(item));
			return new BsonArray(values);
		}

		static BsonValue ToBsonValue(this ObjectService.AttributeInfo attribute, object value)
		{
			if (value == null)
				return null;

			var bsonRepresentation = attribute.IsEnum() ? attribute.GetCustomAttribute<BsonRepresentationAttribute>() : null;
			return bsonRepresentation != null && bsonRepresentation.Representation.Equals(BsonType.String)
				? BsonValue.Create(value.ToString())
				: BsonValue.Create(value);
		}

		/// <summary>
		/// Updates document of an object
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="session">The working session</param>
		/// <param name="object">The object for updating</param>
		/// <param name="attributes">The collection of attributes for updating individually</param>
		/// <param name="options">The options for updating</param>
		/// <returns>ReplaceOneResult or UpdateResult object</returns>
		public static void Update<T>(this IMongoCollection<T> collection, IClientSessionHandle session, T @object, List<string> attributes, UpdateOptions options = null) where T : class
		{
			// check
			if (@object == null)
				throw new ArgumentNullException(nameof(@object), "The object is null");
			else if (attributes == null || attributes.Count < 1)
				throw new ArgumentException("No attribute to update");

			var stopwatch = Stopwatch.StartNew();

			// get collection of all attributes
			var objAttributes = RepositoryMediator.GetEntityDefinition<T>().Attributes;

			// check to use replace (when got generic of primitive or class type member - workaround)
			var useReplace = false;
			foreach (var name in attributes)
			{
				if (name.StartsWith("ExtendedProperties."))
				{
					useReplace = true;
					break;
				}

				var attribute = objAttributes.FirstOrDefault(a => a.Name.IsEquals(name));
				if (attribute != null)
				{
					useReplace = attribute.Type.IsClassType() || (attribute.Type.IsGenericListOrHashSet() && attribute.Type.GenericTypeArguments[0].IsClassType()) || (attribute.Type.IsArray && attribute.Type.GetElementType().IsClassType());
					if (useReplace)
						break;
				}
			}

			// replace whole document (when got generic of primitive or class type member - workaround)
			if (useReplace)
			{
				collection.ReplaceOne(session ?? collection.StartSession(), Builders<T>.Filter.Eq("_id", @object.GetEntityID()), @object, new ReplaceOptions { IsUpsert = options == null || options.IsUpsert });

				stopwatch.Stop();
				if (RepositoryMediator.IsDebugEnabled)
					RepositoryMediator.WriteLogs(new[]
					{
						$"NoSQL: updated attributes got a generic primitive or a class type, then switch to use Replace instead of Update",
						$"- Execution times: {stopwatch.GetElapsedTimes()}",
						$"- Updated attributes: [{attributes.ToString(", ")}]",
						$"- Objects' data for replacing:\r\n\t" + objAttributes.Select(attribute => $"+ @{attribute.Name} ({attribute.Type.GetTypeName(true)}) => [{@object.GetAttributeValue(attribute) ?? "(null)"}]").ToString("\r\n\t") + "\r\n\t+ ExtendedProperties: " + @object.GetAttributeValue("ExtendedProperties")?.ToJson(null).ToString(Newtonsoft.Json.Formatting.None)
					});

				return;
			}

			// update individually
			UpdateDefinition<T> updater = null;
			var updated = "";

			attributes.ForEach(name =>
			{
				var attribute = objAttributes.FirstOrDefault(a => a.Name.IsEquals(name));
				if (attribute != null)
				{
					var value = @object.GetAttributeValue(attribute);
					var isList = value != null && ((attribute.Type.IsGenericListOrHashSet() && attribute.Type.GenericTypeArguments[0].IsClassType()) || (attribute.Type.IsArray && attribute.Type.GetElementType().IsClassType()));
					var type = isList
						? attribute.Type.IsGenericListOrHashSet()
							? attribute.Type.GenericTypeArguments[0]
							: attribute.Type.GetElementType()
						: null;

					updater = updater == null
						? Builders<T>.Update.Set(attribute.Name, isList ? (value as IEnumerable).ToBsonArray(type) : attribute.ToBsonValue(value))
						: updater.Set(attribute.Name, isList ? (value as IEnumerable).ToBsonArray(type) : attribute.ToBsonValue(value));

					if (RepositoryMediator.IsDebugEnabled)
						updated += $"\r\n\t+ @{attribute.Name} ({attribute.Type}) ==> [{value ?? "(null)"}]";
				}
			});

			if (updater != null)
				collection.UpdateOne(session ?? collection.StartSession(), Builders<T>.Filter.Eq("_id", @object.GetEntityID()), updater, options ?? new UpdateOptions { IsUpsert = true });

			stopwatch.Stop();
			if (RepositoryMediator.IsDebugEnabled)
				RepositoryMediator.WriteLogs(new[]
				{
					$"NoSQL: {(updater != null ? "Perform UPDATE command successful" : "No valid update to perform")} [{typeof(T)}#{@object?.GetEntityID()}] @ {collection.CollectionNamespace.CollectionName}",
					$"{(updater != null ? $"Updated attributes:{updated}\r\n" : "")}Execution times: {stopwatch.GetElapsedTimes()}"
				});
		}

		/// <summary>
		/// Updates document of an object
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="object">The object for updating</param>
		/// <param name="attributes">The collection of attributes for updating individually</param>
		/// <param name="options">The options for updating</param>
		/// <returns>ReplaceOneResult or UpdateResult object</returns>
		public static void Update<T>(this IMongoCollection<T> collection, T @object, List<string> attributes, UpdateOptions options = null) where T : class
			=> collection.Update(null, @object, attributes, options);

		/// <summary>
		/// Updates document of an object
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="context">The working context</param>
		/// <param name="dataSource">The data source</param>
		/// <param name="object">The object for updating</param>
		/// <param name="attributes">The collection of attributes for updating individually</param>
		/// <param name="options">The options for updating</param>
		/// <returns></returns>
		public static void Update<T>(this RepositoryContext context, DataSource dataSource, T @object, List<string> attributes, UpdateOptions options = null) where T : class
			=> context.GetCollection<T>(dataSource).Update(context.NoSqlSession, @object, attributes, options);

		/// <summary>
		/// Updates document of an object
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="session">The working session</param>
		/// <param name="object">The object for updating</param>
		/// <param name="update">The definition for updating</param>
		/// <param name="options">The options for updating</param>
		public static UpdateResult Update<T>(this IMongoCollection<T> collection, IClientSessionHandle session, T @object, UpdateDefinition<T> update, UpdateOptions options = null) where T : class
			=> @object != null
				? update != null
					? collection.UpdateOne(session ?? collection.StartSession(), Builders<T>.Filter.Eq("_id", @object.GetEntityID()), update, options)
					: throw new ArgumentNullException(nameof(update), "The update definition is null")
				: throw new ArgumentNullException(nameof(@object), "The object is null");

		/// <summary>
		/// Updates document of an object
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="object">The object for updating</param>
		/// <param name="update">The definition for updating</param>
		/// <param name="options">The options for updating</param>
		public static UpdateResult Update<T>(this IMongoCollection<T> collection, T @object, UpdateDefinition<T> update, UpdateOptions options = null) where T : class
			=> collection.Update(@object, update, options);

		/// <summary>
		/// Updates document of an object
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="context">The working context</param>
		/// <param name="dataSource">The data source</param>
		/// <param name="object">The object for updating</param>
		/// <param name="update">The definition for updating</param>
		/// <param name="options">The options for updating</param>
		/// <returns></returns>
		public static UpdateResult Update<T>(this RepositoryContext context, DataSource dataSource, T @object, UpdateDefinition<T> update, UpdateOptions options = null) where T : class
			=> context.GetCollection<T>(dataSource).Update(context.NoSqlSession, @object, update, options);

		/// <summary>
		/// Updates document of an object
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="session">The working session</param>
		/// <param name="object">The object for updating</param>
		/// <param name="attributes">The collection of attributes for updating individually</param>
		/// <param name="options">The options for updating</param>
		/// <param name="cancellationToken">The cancellation token</param>
		/// <returns></returns>
		public static async Task UpdateAsync<T>(this IMongoCollection<T> collection, IClientSessionHandle session, T @object, List<string> attributes, UpdateOptions options = null, CancellationToken cancellationToken = default) where T : class
		{
			if (@object == null)
				throw new ArgumentNullException(nameof(@object), "The object is null");
			else if (attributes == null || attributes.Count < 1)
				throw new ArgumentException("No attribute to update");

			var stopwatch = Stopwatch.StartNew();

			// get collection of all attributes
			var objAttributes = RepositoryMediator.GetEntityDefinition<T>().Attributes;

			// check to use replace (when got generic of primitive or class type member - workaround)
			var useReplace = false;
			foreach (var name in attributes)
			{
				if (name.StartsWith("ExtendedProperties."))
				{
					useReplace = true;
					break;
				}

				var attribute = objAttributes.FirstOrDefault(a => a.Name.IsEquals(name));
				if (attribute != null)
				{
					useReplace = attribute.Type.IsClassType() || (attribute.Type.IsGenericListOrHashSet() && attribute.Type.GenericTypeArguments[0].IsClassType()) || (attribute.Type.IsArray && attribute.Type.GetElementType().IsClassType());
					if (useReplace)
						break;
				}
			}

			// replace whole document (when got generic of primitive or class type member - workaround)
			if (useReplace)
			{
				await collection.ReplaceOneAsync(session ?? await collection.StartSessionAsync(cancellationToken).ConfigureAwait(false), Builders<T>.Filter.Eq("_id", @object.GetEntityID()), @object, new ReplaceOptions { IsUpsert = options == null || options.IsUpsert }, cancellationToken).ConfigureAwait(false);

				stopwatch.Stop();
				if (RepositoryMediator.IsDebugEnabled)
					RepositoryMediator.WriteLogs(new[]
					{
						$"NoSQL: updated attributes got a generic primitive or a class type, then switch to use Replace instead of Update",
						$"- Execution times: {stopwatch.GetElapsedTimes()}",
						$"- Updated attributes: [{attributes.ToString(", ")}]",
						$"- Objects' data for replacing:\r\n\t" + objAttributes.Select(attribute => $"+ @{attribute.Name} ({attribute.Type.GetTypeName(true)}) => [{@object.GetAttributeValue(attribute) ?? "(null)"}]").ToString("\r\n\t") + "\r\n\t+ ExtendedProperties: " + @object.GetAttributeValue("ExtendedProperties")?.ToJson(null).ToString(Newtonsoft.Json.Formatting.None)
					});

				return;
			}

			// update individually
			UpdateDefinition<T> updater = null;
			var updated = "";

			attributes.ForEach(name =>
			{
				var attribute = objAttributes.FirstOrDefault(a => a.Name.IsEquals(name));
				if (attribute != null)
				{
					var value = @object.GetAttributeValue(attribute);
					var isList = value != null && ((attribute.Type.IsGenericListOrHashSet() && attribute.Type.GenericTypeArguments[0].IsClassType()) || (attribute.Type.IsArray && attribute.Type.GetElementType().IsClassType()));
					var type = isList
						? attribute.Type.IsGenericListOrHashSet()
							? attribute.Type.GenericTypeArguments[0]
							: attribute.Type.GetElementType()
						: null;

					updater = updater == null
						? Builders<T>.Update.Set(attribute.Name, isList ? (value as IEnumerable).ToBsonArray(type) : attribute.ToBsonValue(value))
						: updater.Set(attribute.Name, isList ? (value as IEnumerable).ToBsonArray(type) : attribute.ToBsonValue(value));

					if (RepositoryMediator.IsDebugEnabled)
						updated += $"\r\n\t+ @{attribute.Name} ({attribute.Type}) ==> [{value ?? "(null)"}]";
				}
			});

			if (updater != null)
				await collection.UpdateOneAsync(session ?? await collection.StartSessionAsync(cancellationToken).ConfigureAwait(false), Builders<T>.Filter.Eq("_id", @object.GetEntityID()), updater, options ?? new UpdateOptions { IsUpsert = true }, cancellationToken).ConfigureAwait(false);

			stopwatch.Stop();
			if (RepositoryMediator.IsDebugEnabled)
				RepositoryMediator.WriteLogs(new[]
				{
					$"NoSQL: {(updater != null ? "Perform UPDATE command successful" : "No valid update to perform")} [{typeof(T)}#{@object?.GetEntityID()}] @ {collection.CollectionNamespace.CollectionName}",
					$"{(updater != null ? $"Updated attributes:{updated}\r\n" : "")}Execution times: {stopwatch.GetElapsedTimes()}"
				});
		}

		/// <summary>
		/// Updates document of an object
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="object">The object for updating</param>
		/// <param name="attributes">The collection of attributes for updating individually</param>
		/// <param name="options">The options for updating</param>
		/// <param name="cancellationToken">The cancellation token</param>
		/// <returns></returns>
		public static Task UpdateAsync<T>(this IMongoCollection<T> collection, T @object, List<string> attributes, UpdateOptions options = null, CancellationToken cancellationToken = default) where T : class
			=> collection.UpdateAsync(null, @object, attributes, options, cancellationToken);

		/// <summary>
		/// Updates document of an object
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="context">The working context</param>
		/// <param name="dataSource">The data source</param>
		/// <param name="object">The object for updating</param>
		/// <param name="attributes">The collection of attributes for updating individually</param>
		/// <param name="options">The options for updating</param>
		/// <param name="cancellationToken">The cancellation token</param>
		/// <returns></returns>
		public static Task UpdateAsync<T>(this RepositoryContext context, DataSource dataSource, T @object, List<string> attributes, UpdateOptions options = null, CancellationToken cancellationToken = default) where T : class
			=> context.GetCollection<T>(dataSource).UpdateAsync(context.NoSqlSession, @object, attributes, options, cancellationToken);

		/// <summary>
		/// Updates document of an object
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="session">The working session</param>
		/// <param name="object">The object for updating</param>
		/// <param name="update">The definition for updating</param>
		/// <param name="options">The options for updating</param>
		/// <param name="cancellationToken">The cancellation token</param>
		/// <returns></returns>
		public static async Task<UpdateResult> UpdateAsync<T>(this IMongoCollection<T> collection, IClientSessionHandle session, T @object, UpdateDefinition<T> update, UpdateOptions options = null, CancellationToken cancellationToken = default) where T : class
			=> @object != null
				? update != null
					? await collection.UpdateOneAsync(session ?? await collection.StartSessionAsync(cancellationToken).ConfigureAwait(false), Builders<T>.Filter.Eq("_id", @object.GetEntityID()), update, options, cancellationToken).ConfigureAwait(false)
					: throw new ArgumentNullException(nameof(update), "The update definition is null")
				: throw new ArgumentNullException(nameof(@object), "The object is null");

		/// <summary>
		/// Updates document of an object
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="object">The object for updating</param>
		/// <param name="update">The definition for updating</param>
		/// <param name="options">The options for updating</param>
		/// <param name="cancellationToken">The cancellation token</param>
		/// <returns></returns>
		public static Task<UpdateResult> UpdateAsync<T>(this IMongoCollection<T> collection, T @object, UpdateDefinition<T> update, UpdateOptions options = null, CancellationToken cancellationToken = default) where T : class
			=> collection.UpdateAsync(null, @object, update, options, cancellationToken);

		/// <summary>
		/// Updates document of an object
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="context">The working context</param>
		/// <param name="dataSource">The data source</param>
		/// <param name="object">The object for updating</param>
		/// <param name="update">The definition for updating</param>
		/// <param name="options">The options for updating</param>
		/// <param name="cancellationToken">The cancellation token</param>
		/// <returns></returns>
		public static Task<UpdateResult> UpdateAsync<T>(this RepositoryContext context, DataSource dataSource, T @object, UpdateDefinition<T> update, UpdateOptions options = null, CancellationToken cancellationToken = default) where T : class
			=> context.GetCollection<T>(dataSource).UpdateAsync(context.NoSqlSession, @object, update, options, cancellationToken);
		#endregion

		#region Delete
		/// <summary>
		/// Deletes the document of an object
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="session">The working session</param>
		/// <param name="id"></param>
		/// <param name="options"></param>
		/// <returns></returns>
		public static DeleteResult Delete<T>(this IMongoCollection<T> collection, IClientSessionHandle session, string id, DeleteOptions options = null) where T : class
			=> !string.IsNullOrWhiteSpace(id)
				? collection.DeleteOne(session ?? collection.StartSession(), Builders<T>.Filter.Eq("_id", id), options)
				: null;

		/// <summary>
		/// Deletes the document of an object
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="id"></param>
		/// <param name="options"></param>
		/// <returns></returns>
		public static DeleteResult Delete<T>(this IMongoCollection<T> collection, string id, DeleteOptions options = null) where T : class
			=> collection.Delete(null, id, options);

		/// <summary>
		/// Deletes the document of an object
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="context">The working context</param>
		/// <param name="dataSource">The data source</param>
		/// <param name="id">The identity of the document of an object for deleting</param>
		/// <returns></returns>
		public static DeleteResult Delete<T>(this RepositoryContext context, DataSource dataSource, string id, DeleteOptions options = null) where T : class
			=> context.GetCollection<T>(dataSource).Delete(context.NoSqlSession, id, options);

		/// <summary>
		/// Deletes the document of an object
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="session">The working session</param>
		/// <param name="object"></param>
		/// <param name="options"></param>
		/// <returns></returns>
		public static DeleteResult Delete<T>(this IMongoCollection<T> collection, IClientSessionHandle session, T @object, DeleteOptions options = null) where T : class
			=> @object != null
				? collection.Delete(session, @object.GetEntityID(), options)
				: throw new ArgumentNullException(nameof(@object), "The object is null");

		/// <summary>
		/// Deletes the document of an object
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="object"></param>
		/// <param name="options"></param>
		/// <returns></returns>
		public static DeleteResult Delete<T>(this IMongoCollection<T> collection, T @object, DeleteOptions options = null) where T : class
			=> collection.Delete(null, @object, options);

		/// <summary>
		/// Deletes the document of an object
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="context">The working context</param>
		/// <param name="dataSource">The data source</param>
		/// <param name="object"></param>
		/// <returns></returns>
		public static DeleteResult Delete<T>(this RepositoryContext context, DataSource dataSource, T @object, DeleteOptions options = null) where T : class
			=> context.GetCollection<T>(dataSource).Delete(context.NoSqlSession, @object, options);

		/// <summary>
		/// Deletes the document of an object
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="session">The working session</param>
		/// <param name="id"></param>
		/// <param name="options"></param>
		/// <param name="cancellationToken"></param>
		/// <returns></returns>
		public static async Task<DeleteResult> DeleteAsync<T>(this IMongoCollection<T> collection, IClientSessionHandle session, string id, DeleteOptions options = null, CancellationToken cancellationToken = default) where T : class
			=> !string.IsNullOrWhiteSpace(id)
				? await collection.DeleteOneAsync(session ?? await collection.StartSessionAsync(cancellationToken).ConfigureAwait(false), Builders<T>.Filter.Eq("_id", id), options, cancellationToken).ConfigureAwait(false)
				: null;

		/// <summary>
		/// Deletes the document of an object
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="id"></param>
		/// <param name="options"></param>
		/// <param name="cancellationToken"></param>
		/// <returns></returns>
		public static Task<DeleteResult> DeleteAsync<T>(this IMongoCollection<T> collection, string id, DeleteOptions options = null, CancellationToken cancellationToken = default) where T : class
			=> collection.DeleteAsync(id, options, cancellationToken);

		/// <summary>
		/// Deletes the document of an object
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="context">The working context</param>
		/// <param name="dataSource">The data source</param>
		/// <param name="id">The identity of the document of an object for deleting</param>
		/// <returns></returns>
		public static Task<DeleteResult> DeleteAsync<T>(this RepositoryContext context, DataSource dataSource, string id, DeleteOptions options = null, CancellationToken cancellationToken = default) where T : class
			=> context.GetCollection<T>(dataSource).DeleteAsync(context.NoSqlSession, id, options, cancellationToken);

		/// <summary>
		/// Deletes the document of an object
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="session">The working session</param>
		/// <param name="object"></param>
		/// <param name="options"></param>
		/// <param name="cancellationToken"></param>
		/// <returns></returns>
		public static Task<DeleteResult> DeleteAsync<T>(this IMongoCollection<T> collection, IClientSessionHandle session, T @object, DeleteOptions options = null, CancellationToken cancellationToken = default) where T : class
			=> @object != null
				? collection.DeleteAsync(session, @object.GetEntityID(), options, cancellationToken)
				: Task.FromException<DeleteResult>(new ArgumentNullException(nameof(@object), "The object is null"));

		/// <summary>
		/// Deletes the document of an object
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="object"></param>
		/// <param name="options"></param>
		/// <param name="cancellationToken"></param>
		/// <returns></returns>
		public static Task<DeleteResult> DeleteAsync<T>(this IMongoCollection<T> collection, T @object, DeleteOptions options = null, CancellationToken cancellationToken = default) where T : class
			=> collection.DeleteAsync(@object, options, cancellationToken);

		/// <summary>
		/// Deletes the document of an object
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="context">The working context</param>
		/// <param name="dataSource">The data source</param>
		/// <param name="object"></param>
		/// <returns></returns>
		public static Task<DeleteResult> DeleteAsync<T>(this RepositoryContext context, DataSource dataSource, T @object, DeleteOptions options = null, CancellationToken cancellationToken = default) where T : class
			=> context.GetCollection<T>(dataSource).DeleteAsync(context.NoSqlSession, @object, options, cancellationToken);
		#endregion

		#region Delete (many)
		/// <summary>
		/// Deletes document of multiple objects
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="context">The working context</param>
		/// <param name="dataSource">The data source</param>
		/// <param name="filter">The filter for deleting</param>
		/// <param name="businessRepositoryEntityID">The identity of a business repository entity for working with extended properties/seperated data of a business content-type</param>
		/// <param name="options">The options for deleting</param>
		/// <returns></returns>
		public static DeleteResult DeleteMany<T>(this RepositoryContext context, DataSource dataSource, IFilterBy<T> filter, string businessRepositoryEntityID = null, DeleteOptions options = null) where T : class
		{
			var collection = context.GetCollection<T>(dataSource);
			return collection.DeleteMany(context.NoSqlSession ?? collection.StartSession(), NoSqlHelper.CreateFilterDefinition<T>(filter, businessRepositoryEntityID) ?? Builders<T>.Filter.Empty, options);
		}

		/// <summary>
		/// Deletes document of multiple objects
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="context">The working context</param>
		/// <param name="dataSource">The data source</param>
		/// <param name="filter">The filter for deleting</param>
		/// <param name="businessRepositoryEntityID">The identity of a business repository entity for working with extended properties/seperated data of a business content-type</param>
		/// <param name="options">The options for deleting</param>
		/// <param name="cancellationToken">The cancellation token</param>
		/// <returns></returns>
		public static async Task<DeleteResult> DeleteManyAsync<T>(this RepositoryContext context, DataSource dataSource, IFilterBy<T> filter, string businessRepositoryEntityID = null, DeleteOptions options = null, CancellationToken cancellationToken = default) where T : class
		{
			var collection = context.GetCollection<T>(dataSource);
			return await collection.DeleteManyAsync(context.NoSqlSession ?? await collection.StartSessionAsync(cancellationToken).ConfigureAwait(false), NoSqlHelper.CreateFilterDefinition<T>(filter, businessRepositoryEntityID) ?? Builders<T>.Filter.Empty, options, cancellationToken).ConfigureAwait(false);
		}
		#endregion

		#region Select
		/// <summary>
		/// Finds all the matched documents and return the collection of <see cref="BsonDocument">BsonDocument</see> objects with limited attributes
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="session">The working session</param>
		/// <param name="attributes">The collection of attributes to included in the results (set to null to include identity attribute only)</param>
		/// <param name="filter">The filter-by expression for filtering</param>
		/// <param name="sort">The order-by expression for ordering</param>
		/// <param name="pageSize">The size of one page</param>
		/// <param name="pageNumber">The number of page</param>
		/// <param name="options">The options</param>
		/// <returns></returns>
		public static List<BsonDocument> Select<T>(this IMongoCollection<T> collection, IClientSessionHandle session, IEnumerable<string> attributes, FilterDefinition<T> filter, SortDefinition<T> sort, int pageSize, int pageNumber, FindOptions options = null) where T : class
		{
			var selectFluent = collection.CreateSelectFluent(session ?? collection.StartSession(), attributes, filter, sort, pageSize, pageNumber, options);
			try
			{
				if (RepositoryMediator.IsTraceEnabled)
					RepositoryMediator.WriteLogs($"Select [{typeof(T).GetTypeName()}]\r\n{selectFluent}");
				return selectFluent.ToList();
			}
			catch (Exception ex)
			{
				throw ex.Message.IsContains("Sort operation used more than")
					? new RepositoryOperationException(ex.Message + $"{selectFluent}", ex)
					: new RepositoryOperationException(ex.Message, ex);
			}
		}

		/// <summary>
		/// Finds all the matched documents and return the collection of <see cref="BsonDocument">BsonDocument</see> objects with limited attributes
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="attributes">The collection of attributes to included in the results (set to null to include identity attribute only)</param>
		/// <param name="filter">The filter-by expression for filtering</param>
		/// <param name="sort">The order-by expression for ordering</param>
		/// <param name="pageSize">The size of one page</param>
		/// <param name="pageNumber">The number of page</param>
		/// <param name="options">The options</param>
		/// <returns></returns>
		public static List<BsonDocument> Select<T>(this IMongoCollection<T> collection, IEnumerable<string> attributes, FilterDefinition<T> filter, SortDefinition<T> sort, int pageSize, int pageNumber, FindOptions options = null) where T : class
			=> collection.Select(null, attributes, filter, sort, pageSize, pageNumber, options);

		/// <summary>
		/// Finds all the matched documents and return the collection of <see cref="BsonDocument">BsonDocument</see> objects with limited attributes
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="context">The working context</param>
		/// <param name="dataSource">The data source</param>
		/// <param name="attributes">The collection of attributes to included in the results (set to null to include identity attribute only)</param>
		/// <param name="filter">The filter-by expression for filtering</param>
		/// <param name="sort">The order-by expression for ordering</param>
		/// <param name="pageSize">The size of one page</param>
		/// <param name="pageNumber">The number of page</param>
		/// <param name="businessRepositoryEntityID">The identity of a business repository entity for working with extended properties/seperated data of a business content-type</param>
		/// <param name="autoAssociateWithMultipleParents">true to auto associate with multiple parents (if has - default is true)</param>
		/// <param name="options">The options</param>
		/// <returns></returns>
		public static List<BsonDocument> Select<T>(this RepositoryContext context, DataSource dataSource, IEnumerable<string> attributes, IFilterBy<T> filter, SortBy<T> sort, int pageSize, int pageNumber, string businessRepositoryEntityID = null, bool autoAssociateWithMultipleParents = true, FindOptions options = null) where T : class
		{
			var (Filter, Sort) = RepositoryExtensions.PrepareNoSqlStatements(filter, sort, businessRepositoryEntityID, autoAssociateWithMultipleParents);
			return context.GetCollection<T>(dataSource).Select(context.NoSqlSession, attributes, Filter, Sort, pageSize, pageNumber, options);
		}

		/// <summary>
		/// Finds all the matched documents and return the collection of <see cref="BsonDocument">BsonDocument</see> objects with limited attributes
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="session">The working session</param>
		/// <param name="attributes">The collection of attributes to included in the results (set to null to include identity attribute only)</param>
		/// <param name="filter">The filter-by expression for filtering</param>
		/// <param name="sort">The order-by expression for ordering</param>
		/// <param name="pageSize">The size of one page</param>
		/// <param name="pageNumber">The number of page</param>
		/// <param name="options">The options</param>
		/// <param name="cancellationToken">The cancellation token</param>
		/// <returns></returns>
		public static async Task<List<BsonDocument>> SelectAsync<T>(this IMongoCollection<T> collection, IClientSessionHandle session, IEnumerable<string> attributes, FilterDefinition<T> filter, SortDefinition<T> sort, int pageSize, int pageNumber, FindOptions options = null, CancellationToken cancellationToken = default) where T : class
		{
			var selectFluent = collection.CreateSelectFluent(session ?? await collection.StartSessionAsync(cancellationToken).ConfigureAwait(false), attributes, filter, sort, pageSize, pageNumber, options);
			try
			{
				if (RepositoryMediator.IsTraceEnabled)
					RepositoryMediator.WriteLogs($"Select [{typeof(T).GetTypeName()}]\r\n{selectFluent}");
				return await selectFluent.ToListAsync(cancellationToken).ConfigureAwait(false);
			}
			catch (Exception ex)
			{
				throw ex.Message.IsContains("Sort operation used more than")
					? new RepositoryOperationException(ex.Message + $"{selectFluent}", ex)
					: new RepositoryOperationException(ex.Message, ex);
			}
		}

		/// <summary>
		/// Finds all the matched documents and return the collection of <see cref="BsonDocument">BsonDocument</see> objects with limited attributes
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="attributes">The collection of attributes to included in the results (set to null to include identity attribute only)</param>
		/// <param name="filter">The filter-by expression for filtering</param>
		/// <param name="sort">The order-by expression for ordering</param>
		/// <param name="pageSize">The size of one page</param>
		/// <param name="pageNumber">The number of page</param>
		/// <param name="options">The options</param>
		/// <param name="cancellationToken">The cancellation token</param>
		/// <returns></returns>
		public static Task<List<BsonDocument>> SelectAsync<T>(this IMongoCollection<T> collection, IEnumerable<string> attributes, FilterDefinition<T> filter, SortDefinition<T> sort, int pageSize, int pageNumber, FindOptions options = null, CancellationToken cancellationToken = default) where T : class
			=> collection.SelectAsync(null, attributes, filter, sort, pageSize, pageNumber, options, cancellationToken);

		/// <summary>
		/// Finds all the matched documents and return the collection of <see cref="BsonDocument">BsonDocument</see> objects with limited attributes
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="context">The working context</param>
		/// <param name="dataSource">The data source</param>
		/// <param name="attributes">The collection of attributes to included in the results (set to null to include identity attribute only)</param>
		/// <param name="filter">The filter-by expression for filtering</param>
		/// <param name="sort">The order-by expression for ordering</param>
		/// <param name="pageSize">The size of one page</param>
		/// <param name="pageNumber">The number of page</param>
		/// <param name="businessRepositoryEntityID">The identity of a business repository entity for working with extended properties/seperated data of a business content-type</param>
		/// <param name="autoAssociateWithMultipleParents">true to auto associate with multiple parents (if has - default is true)</param>
		/// <param name="options">The options</param>
		/// <param name="cancellationToken">The cancellation token</param>
		/// <returns></returns>
		public static Task<List<BsonDocument>> SelectAsync<T>(this RepositoryContext context, DataSource dataSource, IEnumerable<string> attributes, IFilterBy<T> filter, SortBy<T> sort, int pageSize, int pageNumber, string businessRepositoryEntityID = null, bool autoAssociateWithMultipleParents = true, FindOptions options = null, CancellationToken cancellationToken = default) where T : class
		{
			var (Filter, Sort) = RepositoryExtensions.PrepareNoSqlStatements(filter, sort, businessRepositoryEntityID, autoAssociateWithMultipleParents);
			return context.GetCollection<T>(dataSource).SelectAsync(context.NoSqlSession, attributes, Filter, Sort, pageSize, pageNumber, options, cancellationToken);
		}
		#endregion

		#region Select (identities)
		/// <summary>
		/// Finds all the matched documents and return the collection of identity attributes
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="session">The working session</param>
		/// <param name="filter">The filter-by expression for filtering</param>
		/// <param name="sort">The order-by expression for ordering</param>
		/// <param name="pageSize">The size of one page</param>
		/// <param name="pageNumber">The number of page</param>
		/// <param name="options">The options</param>
		/// <returns></returns>
		public static List<string> SelectIdentities<T>(this IMongoCollection<T> collection, IClientSessionHandle session, FilterDefinition<T> filter, SortDefinition<T> sort, int pageSize, int pageNumber, FindOptions options = null) where T : class
			=> collection.Select(session, null, filter, sort, pageSize, pageNumber, options)
				.Select(doc => doc["_id"].AsString)
				.ToList();

		/// <summary>
		/// Finds all the matched documents and return the collection of identity attributes
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="filter">The filter-by expression for filtering</param>
		/// <param name="sort">The order-by expression for ordering</param>
		/// <param name="pageSize">The size of one page</param>
		/// <param name="pageNumber">The number of page</param>
		/// <param name="options">The options</param>
		/// <returns></returns>
		public static List<string> SelectIdentities<T>(this IMongoCollection<T> collection, FilterDefinition<T> filter, SortDefinition<T> sort, int pageSize, int pageNumber, FindOptions options = null) where T : class
			=> collection.SelectIdentities(null, filter, sort, pageSize, pageNumber, options);

		/// <summary>
		/// Finds all the matched documents and return the collection of identity attributes
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="context">The working context</param>
		/// <param name="dataSource">The data source</param>
		/// <param name="filter">The filter-by expression for filtering</param>
		/// <param name="sort">The order-by expression for ordering</param>
		/// <param name="pageSize">The size of one page</param>
		/// <param name="pageNumber">The number of page</param>
		/// <param name="businessRepositoryEntityID">The identity of a business repository entity for working with extended properties/seperated data of a business content-type</param>
		/// <param name="autoAssociateWithMultipleParents">true to auto associate with multiple parents (if has - default is true)</param>
		/// <param name="options">The options</param>
		/// <returns></returns>
		public static List<string> SelectIdentities<T>(this RepositoryContext context, DataSource dataSource, IFilterBy<T> filter, SortBy<T> sort, int pageSize, int pageNumber, string businessRepositoryEntityID = null, bool autoAssociateWithMultipleParents = true, FindOptions options = null) where T : class
		{
			var (Filter, Sort) = RepositoryExtensions.PrepareNoSqlStatements(filter, sort, businessRepositoryEntityID, autoAssociateWithMultipleParents);
			return context.GetCollection<T>(dataSource).SelectIdentities(context.NoSqlSession, Filter, Sort, pageSize, pageNumber, options);
		}

		/// <summary>
		/// Finds all the matched documents and return the collection of identity attributes
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="session">The working session</param>
		/// <param name="filter">The filter-by expression for filtering</param>
		/// <param name="sort">The order-by expression for ordering</param>
		/// <param name="pageSize">The size of one page</param>
		/// <param name="pageNumber">The number of page</param>
		/// <param name="options">The options</param>
		/// <param name="cancellationToken">The cancellation token</param>
		/// <returns></returns>
		public static async Task<List<string>> SelectIdentitiesAsync<T>(this IMongoCollection<T> collection, IClientSessionHandle session, FilterDefinition<T> filter, SortDefinition<T> sort, int pageSize, int pageNumber, FindOptions options = null, CancellationToken cancellationToken = default) where T : class
			=> (await collection.SelectAsync(session, null, filter, sort, pageSize, pageNumber, options, cancellationToken).ConfigureAwait(false)).Select(doc => doc["_id"].AsString).ToList();

		/// <summary>
		/// Finds all the matched documents and return the collection of identity attributes
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="filter">The filter-by expression for filtering</param>
		/// <param name="sort">The order-by expression for ordering</param>
		/// <param name="pageSize">The size of one page</param>
		/// <param name="pageNumber">The number of page</param>
		/// <param name="options">The options</param>
		/// <param name="cancellationToken">The cancellation token</param>
		/// <returns></returns>
		public static Task<List<string>> SelectIdentitiesAsync<T>(this IMongoCollection<T> collection, FilterDefinition<T> filter, SortDefinition<T> sort, int pageSize, int pageNumber, FindOptions options = null, CancellationToken cancellationToken = default) where T : class
			=> collection.SelectIdentitiesAsync(null, filter, sort, pageSize, pageNumber, options, cancellationToken);

		/// <summary>
		/// Finds all the matched documents and return the collection of identity attributes
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="context">The working context</param>
		/// <param name="dataSource">The data source</param>
		/// <param name="filter">The filter-by expression for filtering</param>
		/// <param name="sort">The order-by expression for ordering</param>
		/// <param name="pageSize">The size of one page</param>
		/// <param name="pageNumber">The number of page</param>
		/// <param name="businessRepositoryEntityID">The identity of a business repository entity for working with extended properties/seperated data of a business content-type</param>
		/// <param name="autoAssociateWithMultipleParents">true to auto associate with multiple parents (if has - default is true)</param>
		/// <param name="options">The options</param>
		/// <param name="cancellationToken">The cancellation token</param>
		/// <returns></returns>
		public static Task<List<string>> SelectIdentitiesAsync<T>(this RepositoryContext context, DataSource dataSource, IFilterBy<T> filter, SortBy<T> sort, int pageSize, int pageNumber, string businessRepositoryEntityID = null, bool autoAssociateWithMultipleParents = true, FindOptions options = null, CancellationToken cancellationToken = default) where T : class
		{
			var (Filter, Sort) = RepositoryExtensions.PrepareNoSqlStatements(filter, sort, businessRepositoryEntityID, autoAssociateWithMultipleParents);
			return context.GetCollection<T>(dataSource).SelectIdentitiesAsync(context.NoSqlSession, Filter, Sort, pageSize, pageNumber, options, cancellationToken);
		}
		#endregion

		#region Find
		/// <summary>
		/// Finds all the matched documents
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="session">The working session</param>
		/// <param name="filter">The filter-by expression for filtering</param>
		/// <param name="sort">The order-by expression for ordering</param>
		/// <param name="pageSize">The size of one page</param>
		/// <param name="pageNumber">The number of page</param>
		/// <param name="options">The options</param>
		/// <returns></returns>
		public static List<T> Find<T>(this IMongoCollection<T> collection, IClientSessionHandle session, FilterDefinition<T> filter, SortDefinition<T> sort, int pageSize, int pageNumber, FindOptions options = null) where T : class
		{
			var findFluent = collection.CreateFindFluent(session ?? collection.StartSession(), filter, sort, pageSize, pageNumber, options);
			try
			{
				if (RepositoryMediator.IsTraceEnabled)
					RepositoryMediator.WriteLogs($"Find [{typeof(T).GetTypeName()}]\r\n{findFluent}");
				return findFluent.ToList();
			}
			catch (Exception ex)
			{
				throw ex.Message.IsContains("Sort operation used more than")
					? new RepositoryOperationException(ex.Message + $"{findFluent}", ex)
					: new RepositoryOperationException(ex.Message, ex);
			}
		}

		/// <summary>
		/// Finds all the matched documents
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="filter">The filter-by expression for filtering</param>
		/// <param name="sort">The order-by expression for ordering</param>
		/// <param name="pageSize">The size of one page</param>
		/// <param name="pageNumber">The number of page</param>
		/// <param name="options">The options</param>
		/// <returns></returns>
		public static List<T> Find<T>(this IMongoCollection<T> collection, FilterDefinition<T> filter, SortDefinition<T> sort, int pageSize, int pageNumber, FindOptions options = null) where T : class
			=> collection.Find(null, filter, sort, pageSize, pageNumber, options);

		/// <summary>
		/// Finds all the matched documents
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="context">The working context</param>
		/// <param name="dataSource">The data source</param>
		/// <param name="filter">The filter-by expression for filtering</param>
		/// <param name="sort">The order-by expression for ordering</param>
		/// <param name="pageSize">The size of one page</param>
		/// <param name="pageNumber">The number of page</param>
		/// <param name="businessRepositoryEntityID">The identity of a business repository entity for working with extended properties/seperated data of a business content-type</param>
		/// <param name="autoAssociateWithMultipleParents">true to auto associate with multiple parents (if has - default is true)</param>
		/// <param name="options">The options</param>
		/// <returns></returns>
		public static List<T> Find<T>(this RepositoryContext context, DataSource dataSource, IFilterBy<T> filter, SortBy<T> sort, int pageSize, int pageNumber, string businessRepositoryEntityID = null, bool autoAssociateWithMultipleParents = true, FindOptions options = null) where T : class
		{
			var (Filter, Sort) = RepositoryExtensions.PrepareNoSqlStatements(filter, sort, businessRepositoryEntityID, autoAssociateWithMultipleParents);
			return context.GetCollection<T>(dataSource).Find(context.NoSqlSession, Filter, Sort, pageSize, pageNumber, options);
		}

		/// <summary>
		/// Finds all the matched documents
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="session">The working session</param>
		/// <param name="filter">The filter-by expression for filtering</param>
		/// <param name="sort">The order-by expression for ordering</param>
		/// <param name="pageSize">The size of one page</param>
		/// <param name="pageNumber">The number of page</param>
		/// <param name="options">The options</param>
		/// <param name="cancellationToken">The cancellation token</param>
		/// <returns></returns>
		public static async Task<List<T>> FindAsync<T>(this IMongoCollection<T> collection, IClientSessionHandle session, FilterDefinition<T> filter, SortDefinition<T> sort, int pageSize, int pageNumber, FindOptions options = null, CancellationToken cancellationToken = default) where T : class
		{
			var findFluent = collection.CreateFindFluent(session ?? await collection.StartSessionAsync(cancellationToken).ConfigureAwait(false), filter, sort, pageSize, pageNumber, options);
			try
			{
				if (RepositoryMediator.IsTraceEnabled)
					RepositoryMediator.WriteLogs($"Find [{typeof(T).GetTypeName()}]\r\n{findFluent}");
				return await findFluent.ToListAsync(cancellationToken).ConfigureAwait(false);
			}
			catch (Exception ex)
			{
				throw ex.Message.IsContains("Sort operation used more than")
					? new RepositoryOperationException(ex.Message + $"{findFluent}", ex)
					: new RepositoryOperationException(ex.Message, ex);
			}
		}

		/// <summary>
		/// Finds all the matched documents
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="filter">The filter-by expression for filtering</param>
		/// <param name="sort">The order-by expression for ordering</param>
		/// <param name="pageSize">The size of one page</param>
		/// <param name="pageNumber">The number of page</param>
		/// <param name="options">The options</param>
		/// <param name="cancellationToken">The cancellation token</param>
		/// <returns></returns>
		public static Task<List<T>> FindAsync<T>(this IMongoCollection<T> collection, FilterDefinition<T> filter, SortDefinition<T> sort, int pageSize, int pageNumber, FindOptions options = null, CancellationToken cancellationToken = default) where T : class
			=> collection.FindAsync(null, filter, sort, pageSize, pageNumber, options, cancellationToken);

		/// <summary>
		/// Finds all the matched documents
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="context">The working context</param>
		/// <param name="dataSource">The data source</param>
		/// <param name="filter">The filter-by expression for filtering</param>
		/// <param name="sort">The order-by expression for ordering</param>
		/// <param name="pageSize">The size of one page</param>
		/// <param name="pageNumber">The number of page</param>
		/// <param name="businessRepositoryEntityID">The identity of a business repository entity for working with extended properties/seperated data of a business content-type</param>
		/// <param name="autoAssociateWithMultipleParents">true to auto associate with multiple parents (if has - default is true)</param>
		/// <param name="options">The options</param>
		/// <param name="cancellationToken">The options</param>
		/// <returns></returns>
		public static Task<List<T>> FindAsync<T>(this RepositoryContext context, DataSource dataSource, IFilterBy<T> filter, SortBy<T> sort, int pageSize, int pageNumber, string businessRepositoryEntityID = null, bool autoAssociateWithMultipleParents = true, FindOptions options = null, CancellationToken cancellationToken = default) where T : class
		{
			var (Filter, Sort) = RepositoryExtensions.PrepareNoSqlStatements(filter, sort, businessRepositoryEntityID, autoAssociateWithMultipleParents);
			return context.GetCollection<T>(dataSource).FindAsync(context.NoSqlSession, Filter, Sort, pageSize, pageNumber, options, cancellationToken);
		}
		#endregion

		#region Find (by identities)
		/// <summary>
		/// Finds all the documents that specified by identity
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="context">The working context</param>
		/// <param name="dataSource">The data source</param>
		/// <param name="identities">The collection of identities for finding</param>
		/// <param name="sort">The order-by expression for ordering</param>
		/// <param name="businessRepositoryEntityID">The identity of a business repository entity for working with extended properties/seperated data of a business content-type</param>
		/// <param name="options">The options</param>
		/// <returns></returns>
		public static List<T> Find<T>(this RepositoryContext context, DataSource dataSource, List<string> identities, SortBy<T> sort = null, string businessRepositoryEntityID = null, FindOptions options = null) where T : class
		{
			if (identities == null || identities.Count < 1)
				return new List<T>();
			var (Filter, Sort) = RepositoryExtensions.PrepareNoSqlStatements(Filters<T>.Or(identities.Select(id => Filters<T>.Equals("ID", id))), sort, businessRepositoryEntityID, false);
			return context.GetCollection<T>(dataSource).Find(context.NoSqlSession, Filter, Sort, 0, 1, options);
		}

		/// <summary>
		/// Finds all the documents that specified by identity
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="context">The working context</param>
		/// <param name="dataSource">The data source</param>
		/// <param name="identities">The collection of identities for finding</param>
		/// <param name="sort">The order-by expression for ordering</param>
		/// <param name="businessRepositoryEntityID">The identity of a business repository entity for working with extended properties/seperated data of a business content-type</param>
		/// <param name="options">The options</param>
		/// <param name="cancellationToken">The cancellation token</param>
		/// <returns></returns>
		public static Task<List<T>> FindAsync<T>(this RepositoryContext context, DataSource dataSource, List<string> identities, SortBy<T> sort = null, string businessRepositoryEntityID = null, FindOptions options = null, CancellationToken cancellationToken = default) where T : class
		{
			if (identities == null || identities.Count < 1)
				return Task.FromResult(new List<T>());
			var (Filter, Sort) = RepositoryExtensions.PrepareNoSqlStatements(Filters<T>.Or(identities.Select(id => Filters<T>.Equals("ID", id))), sort, businessRepositoryEntityID, false);
			return context.GetCollection<T>(dataSource).FindAsync(context.NoSqlSession, Filter, Sort, 0, 1, options, cancellationToken);
		}
		#endregion

		#region Count
		/// <summary>
		/// Counts the number of all the matched documents
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="context">The working context</param>
		/// <param name="dataSource">The data source for counting</param>
		/// <param name="filter">The filter-by expression for counting</param>
		/// <param name="businessRepositoryEntityID">The identity of a business repository entity for working with extended properties/seperated data of a business content-type</param>
		/// <param name="autoAssociateWithMultipleParents">true to auto associate with multiple parents (if has - default is true)</param>
		/// <param name="options">The options</param>
		/// <returns></returns>
		public static long Count<T>(this RepositoryContext context, DataSource dataSource, IFilterBy<T> filter, string businessRepositoryEntityID = null, bool autoAssociateWithMultipleParents = true, CountOptions options = null) where T : class
		{
			var (Filter, _) = RepositoryExtensions.PrepareNoSqlStatements(filter, null, businessRepositoryEntityID, autoAssociateWithMultipleParents);
			var collection = context.GetCollection<T>(dataSource);
			if (RepositoryMediator.IsTraceEnabled)
				RepositoryMediator.WriteLogs($"Count [{typeof(T).GetTypeName()}]\r\n{(Filter ?? Builders<T>.Filter.Empty).Render()}");
			return collection.CountDocuments(context.NoSqlSession ?? collection.StartSession(), Filter ?? Builders<T>.Filter.Empty, options);
		}

		/// <summary>
		/// Counts the number of all the matched documents
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="context">The working context</param>
		/// <param name="dataSource">The data source for counting</param>
		/// <param name="filter">The filter-by expression for counting</param>
		/// <param name="businessRepositoryEntityID">The identity of a business repository entity for working with extended properties/seperated data of a business content-type</param>
		/// <param name="autoAssociateWithMultipleParents">true to auto associate with multiple parents (if has - default is true)</param>
		/// <param name="options">The options</param>
		/// <param name="cancellationToken">The cancellation token</param>
		/// <returns></returns>
		public static async Task<long> CountAsync<T>(this RepositoryContext context, DataSource dataSource, IFilterBy<T> filter, string businessRepositoryEntityID = null, bool autoAssociateWithMultipleParents = true, CountOptions options = null, CancellationToken cancellationToken = default) where T : class
		{
			var (Filter, _) = RepositoryExtensions.PrepareNoSqlStatements(filter, null, businessRepositoryEntityID, autoAssociateWithMultipleParents);
			var collection = context.GetCollection<T>(dataSource);
			if (RepositoryMediator.IsTraceEnabled)
				RepositoryMediator.WriteLogs($"Count [{typeof(T).GetTypeName()}]\r\n{(Filter ?? Builders<T>.Filter.Empty).Render()}");
			return await collection.CountDocumentsAsync(context.NoSqlSession ?? await collection.StartSessionAsync(cancellationToken).ConfigureAwait(false), Filter ?? Builders<T>.Filter.Empty, options, cancellationToken).ConfigureAwait(false);
		}
		#endregion

		#region Search
		/// <summary>
		/// Searchs all the matched documents
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="session">The working session</param>
		/// <param name="query"></param>
		/// <param name="filter"></param>
		/// <param name="sort"></param>
		/// <param name="scoreProperty"></param>
		/// <param name="pageSize"></param>
		/// <param name="pageNumber"></param>
		/// <param name="options"></param>
		/// <returns></returns>
		public static List<T> Search<T>(this IMongoCollection<T> collection, IClientSessionHandle session, string query, FilterDefinition<T> filter, SortDefinition<T> sort, string scoreProperty, int pageSize, int pageNumber, FindOptions options = null) where T : class
		{
			var searchFluent = collection.CreateSearchFluent(session ?? collection.StartSession(), query, filter, sort, scoreProperty, null, pageSize, pageNumber, options);
			try
			{
				if (RepositoryMediator.IsTraceEnabled)
					RepositoryMediator.WriteLogs($"Search [{typeof(T).GetTypeName()}]\r\n{searchFluent}");
				return searchFluent.ToList();
			}
			catch (Exception ex)
			{
				throw ex.Message.IsContains("Sort operation used more than")
					? new RepositoryOperationException(ex.Message + $"{searchFluent}", ex)
					: new RepositoryOperationException(ex.Message, ex);
			}
		}

		/// <summary>
		/// Searchs all the matched documents
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="query"></param>
		/// <param name="filter"></param>
		/// <param name="sort"></param>
		/// <param name="scoreProperty"></param>
		/// <param name="pageSize"></param>
		/// <param name="pageNumber"></param>
		/// <param name="options"></param>
		/// <returns></returns>
		public static List<T> Search<T>(this IMongoCollection<T> collection, string query, FilterDefinition<T> filter, SortDefinition<T> sort, string scoreProperty, int pageSize, int pageNumber, FindOptions options = null) where T : class
			=> collection.Search(null, query, filter, sort, scoreProperty, pageSize, pageNumber, options);

		/// <summary>
		/// Searchs all the matched documents
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="query"></param>
		/// <param name="filter"></param>
		/// <param name="sort"></param>
		/// <param name="pageSize"></param>
		/// <param name="pageNumber"></param>
		/// <param name="options"></param>
		/// <returns></returns>
		public static List<T> Search<T>(this IMongoCollection<T> collection, string query, FilterDefinition<T> filter, SortDefinition<T> sort, int pageSize, int pageNumber, FindOptions options = null) where T : class
			=> collection.Search(query, filter, sort, null, pageSize, pageNumber, options);

		/// <summary>
		/// Searchs all the matched documents
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="query"></param>
		/// <param name="sort"></param>
		/// <param name="scoreProperty"></param>
		/// <param name="pageSize"></param>
		/// <param name="pageNumber"></param>
		/// <param name="businessRepositoryEntityID">The identity of a business repository entity for working with extended properties/seperated data of a business content-type</param>
		/// <param name="options">The options</param>
		/// <returns></returns>
		public static List<T> Search<T>(this IMongoCollection<T> collection, string query, SortDefinition<T> sort, string scoreProperty, int pageSize, int pageNumber, string businessRepositoryEntityID = null, FindOptions options = null) where T : class
			=> collection.Search(query, NoSqlHelper.CreateFilterDefinition<T>(null, businessRepositoryEntityID), sort, scoreProperty, pageSize, pageNumber, options);

		/// <summary>
		/// Searchs all the matched documents
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="context">The working context</param>
		/// <param name="dataSource">The data source for searching</param>
		/// <param name="query">The text query for searching</param>
		/// <param name="filter">The additional filtering expression</param>
		/// <param name="sort">The additional sorting expression</param>
		/// <param name="pageSize">The size of one page</param>
		/// <param name="pageNumber">The number of the page</param>
		/// <param name="businessRepositoryEntityID">The identity of a business repository entity for working with extended properties/seperated data of a business content-type</param>
		/// <param name="options">The options</param>
		/// <returns></returns>
		public static List<T> Search<T>(this RepositoryContext context, DataSource dataSource, string query, IFilterBy<T> filter, SortBy<T> sort, int pageSize, int pageNumber, string businessRepositoryEntityID = null, FindOptions options = null) where T : class
			=> context.GetCollection<T>(dataSource).Search(context.NoSqlSession, query, NoSqlHelper.CreateFilterDefinition(filter, businessRepositoryEntityID), sort?.GetNoSqlStatement(), null, pageSize, pageNumber, options);

		/// <summary>
		/// Searchs all the matched documents
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="query"></param>
		/// <param name="filter"></param>
		/// <param name="sort"></param>
		/// <param name="scoreProperty"></param>
		/// <param name="pageSize"></param>
		/// <param name="pageNumber"></param>
		/// <param name="options">The options</param>
		/// <param name="cancellationToken"></param>
		/// <returns></returns>
		public static async Task<List<T>> SearchAsync<T>(this IMongoCollection<T> collection, IClientSessionHandle session, string query, FilterDefinition<T> filter, SortDefinition<T> sort, string scoreProperty, int pageSize, int pageNumber, FindOptions options = null, CancellationToken cancellationToken = default) where T : class
		{
			var searchFluent = collection.CreateSearchFluent(session ?? await collection.StartSessionAsync(cancellationToken).ConfigureAwait(false), query, filter, sort, scoreProperty, null, pageSize, pageNumber, options);
			try
			{
				if (RepositoryMediator.IsTraceEnabled)
					RepositoryMediator.WriteLogs($"Search [{typeof(T).GetTypeName()}]\r\n{searchFluent}");
				return await searchFluent.ToListAsync(cancellationToken).ConfigureAwait(false);
			}
			catch (Exception ex)
			{
				throw ex.Message.IsContains("Sort operation used more than")
					? new RepositoryOperationException(ex.Message + $"{searchFluent}", ex)
					: new RepositoryOperationException(ex.Message, ex);
			}
		}

		/// <summary>
		/// Searchs all the matched documents
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="query"></param>
		/// <param name="filter"></param>
		/// <param name="sort"></param>
		/// <param name="scoreProperty"></param>
		/// <param name="pageSize"></param>
		/// <param name="pageNumber"></param>
		/// <param name="options">The options</param>
		/// <param name="cancellationToken"></param>
		/// <returns></returns>
		public static Task<List<T>> SearchAsync<T>(this IMongoCollection<T> collection, string query, FilterDefinition<T> filter, SortDefinition<T> sort, string scoreProperty, int pageSize, int pageNumber, FindOptions options = null, CancellationToken cancellationToken = default) where T : class
			=> collection.SearchAsync(null, query, filter, sort, scoreProperty, pageSize, pageNumber, options, cancellationToken);

		/// <summary>
		/// Searchs all the matched documents
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="query"></param>
		/// <param name="filter"></param>
		/// <param name="sort"></param>
		/// <param name="pageSize"></param>
		/// <param name="pageNumber"></param>
		/// <param name="options">The options</param>
		/// <param name="cancellationToken"></param>
		/// <returns></returns>
		public static Task<List<T>> SearchAsync<T>(this IMongoCollection<T> collection, string query, FilterDefinition<T> filter, SortDefinition<T> sort, int pageSize, int pageNumber, FindOptions options = null, CancellationToken cancellationToken = default) where T : class
			=> collection.SearchAsync(query, filter, sort, null, pageSize, pageNumber, options, cancellationToken);

		/// <summary>
		/// Searchs all the matched documents
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="query"></param>
		/// <param name="sort"></param>
		/// <param name="scoreProperty"></param>
		/// <param name="pageSize"></param>
		/// <param name="pageNumber"></param>
		/// <param name="businessRepositoryEntityID">The identity of a business repository entity for working with extended properties/seperated data of a business content-type</param>
		/// <param name="options">The options</param>
		/// <param name="cancellationToken"></param>
		/// <returns></returns>
		public static Task<List<T>> SearchAsync<T>(this IMongoCollection<T> collection, string query, SortDefinition<T> sort, string scoreProperty, int pageSize, int pageNumber, string businessRepositoryEntityID = null, FindOptions options = null, CancellationToken cancellationToken = default) where T : class
			=> collection.SearchAsync(query, NoSqlHelper.CreateFilterDefinition<T>(null, businessRepositoryEntityID), sort, scoreProperty, pageSize, pageNumber, options, cancellationToken);

		/// <summary>
		/// Searchs all the matched documents
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="context">The working context</param>
		/// <param name="dataSource">The data source for searching</param>
		/// <param name="query">The text query for searching</param>
		/// <param name="filter">The additional filtering expression</param>
		/// <param name="sort">The additional sorting expression</param>
		/// <param name="pageSize">The size of one page</param>
		/// <param name="pageNumber">The number of the page</param>
		/// <param name="businessRepositoryEntityID">The identity of a business repository entity for working with extended properties/seperated data of a business content-type</param>
		/// <param name="options">The options</param>
		/// <param name="cancellationToken"></param>
		/// <returns></returns>
		public static Task<List<T>> SearchAsync<T>(this RepositoryContext context, DataSource dataSource, string query, IFilterBy<T> filter, SortBy<T> sort, int pageSize, int pageNumber, string businessRepositoryEntityID = null, FindOptions options = null, CancellationToken cancellationToken = default) where T : class
			=> context.GetCollection<T>(dataSource).SearchAsync(context.NoSqlSession, query, NoSqlHelper.CreateFilterDefinition(filter, businessRepositoryEntityID), sort?.GetNoSqlStatement(), null, pageSize, pageNumber, options, cancellationToken);
		#endregion

		#region Search (identities)
		/// <summary>
		/// Searchs all the matched documents and return the collection of identities
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="session">The working session</param>
		/// <param name="query"></param>
		/// <param name="filter"></param>
		/// <param name="sort"></param>
		/// <param name="scoreProperty"></param>
		/// <param name="pageSize"></param>
		/// <param name="pageNumber"></param>
		/// <param name="options">The options</param>
		/// <returns></returns>
		public static List<string> SearchIdentities<T>(this IMongoCollection<T> collection, IClientSessionHandle session, string query, FilterDefinition<T> filter, SortDefinition<T> sort, string scoreProperty, int pageSize, int pageNumber, FindOptions options = null) where T : class
		{
			var searchFluent = collection.CreateSearchFluent(session ?? collection.StartSession(), query, filter, sort, scoreProperty, null, pageSize, pageNumber, options).Project(NoSqlHelper.CreateProjectionDefinition<T>(scoreProperty));
			try
			{
				if (RepositoryMediator.IsTraceEnabled)
					RepositoryMediator.WriteLogs($"Search identities [{typeof(T).GetTypeName()}]\r\n{searchFluent}");
				return searchFluent.ToList().Select(doc => doc["_id"].AsString).ToList();
			}
			catch (Exception ex)
			{
				throw ex.Message.IsContains("Sort operation used more than")
					? new RepositoryOperationException(ex.Message + $"{searchFluent}", ex)
					: new RepositoryOperationException(ex.Message, ex);
			}
		}

		/// <summary>
		/// Searchs all the matched documents and return the collection of identities
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="query"></param>
		/// <param name="filter"></param>
		/// <param name="pageSize"></param>
		/// <param name="pageNumber"></param>
		/// <returns></returns>
		public static List<string> SearchIdentities<T>(this IMongoCollection<T> collection, string query, FilterDefinition<T> filter, int pageSize, int pageNumber) where T : class
			=> collection.SearchIdentities(null, query, filter, null, null, pageSize, pageNumber);

		/// <summary>
		/// Searchs all the matched documents and return the collection of identities
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="context">The working context</param>
		/// <param name="dataSource">The data source for searching</param>
		/// <param name="query">The text query for searching</param>
		/// <param name="filter">The additional filtering expression</param>
		/// <param name="sort">The additional sorting expression</param>
		/// <param name="pageSize">The size of one page</param>
		/// <param name="pageNumber">The number of the page</param>
		/// <param name="businessRepositoryEntityID">The identity of a business repository entity for working with extended properties/seperated data of a business content-type</param>
		/// <param name="options">The options</param>
		/// <returns></returns>
		public static List<string> SearchIdentities<T>(this RepositoryContext context, DataSource dataSource, string query, IFilterBy<T> filter, SortBy<T> sort, int pageSize, int pageNumber, string businessRepositoryEntityID = null, FindOptions options = null) where T : class
			=> context.GetCollection<T>(dataSource).SearchIdentities(context.NoSqlSession, query, NoSqlHelper.CreateFilterDefinition(filter, businessRepositoryEntityID), sort?.GetNoSqlStatement(), null, pageSize, pageNumber, options);

		/// <summary>
		/// Searchs all the matched documents and return the collection of identities
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="session">The working session</param>
		/// <param name="scoreProperty"></param>
		/// <param name="query"></param>
		/// <param name="filter"></param>
		/// <param name="pageSize"></param>
		/// <param name="pageNumber"></param>
		/// <param name="options">The options</param>
		/// <param name="cancellationToken"></param>
		/// <returns></returns>
		public static async Task<List<string>> SearchIdentitiesAsync<T>(this IMongoCollection<T> collection, IClientSessionHandle session, string query, FilterDefinition<T> filter, SortDefinition<T> sort, string scoreProperty, int pageSize, int pageNumber, FindOptions options = null, CancellationToken cancellationToken = default) where T : class
		{
			var searchFluent = collection.CreateSearchFluent(session ?? await collection.StartSessionAsync(cancellationToken).ConfigureAwait(false), query, filter, sort, scoreProperty, null, pageSize, pageNumber, options).Project(NoSqlHelper.CreateProjectionDefinition<T>(scoreProperty));
			try
			{
				if (RepositoryMediator.IsTraceEnabled)
					RepositoryMediator.WriteLogs($"Search identities [{typeof(T).GetTypeName()}]\r\n{searchFluent}");
				return (await searchFluent.ToListAsync(cancellationToken).ConfigureAwait(false)).Select(doc => doc["_id"].AsString).ToList();
			}
			catch (Exception ex)
			{
				throw ex.Message.IsContains("Sort operation used more than")
					? new RepositoryOperationException(ex.Message + $"{searchFluent}", ex)
					: new RepositoryOperationException(ex.Message, ex);
			}
		}

		/// <summary>
		/// Searchs all the matched documents and return the collection of identities
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="query"></param>
		/// <param name="filter"></param>
		/// <param name="pageSize"></param>
		/// <param name="pageNumber"></param>
		/// <param name="options">The options</param>
		/// <param name="cancellationToken"></param>
		/// <returns></returns>
		public static Task<List<string>> SearchIdentitiesAsync<T>(this IMongoCollection<T> collection, string query, FilterDefinition<T> filter, int pageSize, int pageNumber, FindOptions options = null, CancellationToken cancellationToken = default) where T : class
			=> collection.SearchIdentitiesAsync(null, query, filter, null, null, pageSize, pageNumber, options, cancellationToken);

		/// <summary>
		/// Searchs all the matched documents and return the collection of identities
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="context">The working context</param>
		/// <param name="dataSource">The data source for searching</param>
		/// <param name="query">The text query for searching</param>
		/// <param name="filter">The additional filtering expression</param>
		/// <param name="sort">The additional sorting expression</param>
		/// <param name="pageSize">The size of one page</param>
		/// <param name="pageNumber">The number of the page</param>
		/// <param name="businessRepositoryEntityID">The identity of a business repository entity for working with extended properties/seperated data of a business content-type</param>
		/// <param name="options">The options</param>
		/// <param name="cancellationToken"></param>
		/// <returns></returns>
		public static Task<List<string>> SearchIdentitiesAsync<T>(this RepositoryContext context, DataSource dataSource, string query, IFilterBy<T> filter, SortBy<T> sort, int pageSize, int pageNumber, string businessRepositoryEntityID = null, FindOptions options = null, CancellationToken cancellationToken = default) where T : class
			=> context.GetCollection<T>(dataSource).SearchIdentitiesAsync(context.NoSqlSession, query, NoSqlHelper.CreateFilterDefinition(filter, businessRepositoryEntityID), sort?.GetNoSqlStatement(), null, pageSize, pageNumber, options, cancellationToken);
		#endregion

		#region Count (searching)
		/// <summary>
		/// Counts the number of all the matched documents
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="session">The working session</param>
		/// <param name="query">The text query for counting</param>
		/// <param name="filter">The additional filter-by expression for counting</param>
		/// <param name="options">The options</param>
		/// <returns></returns>
		public static long Count<T>(this IMongoCollection<T> collection, IClientSessionHandle session, string query, FilterDefinition<T> filter, CountOptions options = null) where T : class
		{
			var filterDefinition = filter != null && !filter.Equals(Builders<T>.Filter.Empty)
				? query.CreateFilterDefinition<T>() & filter
				: query.CreateFilterDefinition<T>();
			if (RepositoryMediator.IsTraceEnabled)
				RepositoryMediator.WriteLogs($"Count [{typeof(T).GetTypeName()}]\r\n{filterDefinition.Render()}");
			return collection.CountDocuments(session ?? collection.StartSession(), filterDefinition, options);
		}

		/// <summary>
		/// Counts the number of all the matched documents
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="query">The text query for counting</param>
		/// <param name="filter">The additional filter-by expression for counting</param>
		/// <param name="options">The options</param>
		/// <returns></returns>
		public static long Count<T>(this IMongoCollection<T> collection, string query, FilterDefinition<T> filter, CountOptions options = null) where T : class
			=> collection.Count(null, query, filter, options);

		/// <summary>
		/// Counts the number of all the matched documents
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="context">The working context</param>
		/// <param name="dataSource">The data source for counting</param>
		/// <param name="query">The text query for counting</param>
		/// <param name="filter">The additional filter-by expression for counting</param>
		/// <param name="businessRepositoryEntityID">The identity of a business repository entity for working with extended properties/seperated data of a business content-type</param>
		/// <param name="options">The options</param>
		/// <returns></returns>
		public static long Count<T>(this RepositoryContext context, DataSource dataSource, string query, IFilterBy<T> filter = null, string businessRepositoryEntityID = null, CountOptions options = null) where T : class
			=> context.GetCollection<T>(dataSource).Count(context.NoSqlSession, query, NoSqlHelper.CreateFilterDefinition(filter, businessRepositoryEntityID), options);

		/// <summary>
		/// Counts the number of all the matched documents
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="session">The working session</param>
		/// <param name="query">The text query for counting</param>
		/// <param name="filter">The additional filter-by expression for counting</param>
		/// <param name="options">The options</param>
		/// <param name="cancellationToken">The cancellation token</param>
		/// <returns></returns>
		public static async Task<long> CountAsync<T>(this IMongoCollection<T> collection, IClientSessionHandle session, string query, FilterDefinition<T> filter, CountOptions options = null, CancellationToken cancellationToken = default) where T : class
		{
			var filterDefinition = filter != null && !filter.Equals(Builders<T>.Filter.Empty)
				? query.CreateFilterDefinition<T>() & filter
				: query.CreateFilterDefinition<T>();
			if (RepositoryMediator.IsTraceEnabled)
				RepositoryMediator.WriteLogs($"Count [{typeof(T).GetTypeName()}]\r\n{filterDefinition.Render()}");
			return await collection.CountDocumentsAsync(session ?? await collection.StartSessionAsync(cancellationToken).ConfigureAwait(false), filterDefinition, options, cancellationToken).ConfigureAwait(false);
		}

		/// <summary>
		/// Counts the number of all the matched documents
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="collection"></param>
		/// <param name="query">The text query for counting</param>
		/// <param name="filter">The additional filter-by expression for counting</param>
		/// <param name="options">The options</param>
		/// <param name="cancellationToken">The cancellation token</param>
		/// <returns></returns>
		public static Task<long> CountAsync<T>(this IMongoCollection<T> collection, string query, FilterDefinition<T> filter, CountOptions options = null, CancellationToken cancellationToken = default) where T : class
			=> collection.CountAsync(null, query, filter, options, cancellationToken);

		/// <summary>
		/// Counts the number of all the matched documents
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="context">The working context</param>
		/// <param name="dataSource">The data source for counting</param>
		/// <param name="query">The text query for counting</param>
		/// <param name="filter">The additional filter-by expression for counting</param>
		/// <param name="businessRepositoryEntityID">The identity of a business repository entity for working with extended properties/seperated data of a business content-type</param>
		/// <param name="options">The options</param>
		/// <param name="cancellationToken">The cancellation token</param>
		/// <returns></returns>
		public static Task<long> CountAsync<T>(this RepositoryContext context, DataSource dataSource, string query, IFilterBy<T> filter = null, string businessRepositoryEntityID = null, CountOptions options = null, CancellationToken cancellationToken = default) where T : class
			=> context.GetCollection<T>(dataSource).CountAsync(context.NoSqlSession, query, NoSqlHelper.CreateFilterDefinition(filter, businessRepositoryEntityID), options, cancellationToken);
		#endregion

		#region Schemas & Indexes
		/// <summary>
		/// Ensures the indexes of an entity-definition
		/// </summary>
		/// <param name="definition"></param>
		/// <param name="dataSource"></param>
		/// <param name="tracker"></param>
		/// <param name="cancellationToken"></param>
		/// <returns></returns>
		public static async Task EnsureIndexesAsync(this EntityDefinition definition, DataSource dataSource, Action<string, Exception> tracker = null, CancellationToken cancellationToken = default)
		{
			// prepare
			var prefix = "IDX_" + definition.CollectionName;
			var normalIndexes = new Dictionary<string, List<AttributeInfo>>(StringComparer.OrdinalIgnoreCase)
			{
				{ prefix, new List<AttributeInfo>() }
			};
			var uniqueIndexes = new Dictionary<string, List<AttributeInfo>>(StringComparer.OrdinalIgnoreCase);
			var sortables = definition.Attributes.Where(attribute => attribute.IsSortable()).ToList();

			// prepare unique indexes
			sortables.ForEach(attribute =>
			{
				var sortInfo = attribute.GetCustomAttribute<SortableAttribute>();
				if (!string.IsNullOrWhiteSpace(sortInfo.UniqueIndexName))
				{
					var name = $"{prefix}_{sortInfo.UniqueIndexName}";
					if (uniqueIndexes.TryGetValue(name, out var indexes))
						indexes.Add(attribute);
					else
						uniqueIndexes.Add(name, new List<AttributeInfo> { attribute });
				}
			});

			// prepare normal indexes
			sortables.ForEach(attribute =>
			{
				var sortInfo = attribute.GetCustomAttribute<SortableAttribute>();
				if (!string.IsNullOrWhiteSpace(sortInfo.IndexName))
				{
					var name = $"{prefix}_{sortInfo.IndexName}";
					if (normalIndexes.TryGetValue(name, out var indexes))
						indexes.Add(attribute);
					else
						normalIndexes.Add(name, new List<AttributeInfo> { attribute });
				}
			});

			// prepare compound indexes
			sortables.ForEach(attribute =>
			{
				var sortInfo = attribute.GetCustomAttribute<SortableAttribute>();
				if (!string.IsNullOrWhiteSpace(sortInfo.CompoundIndexName))
				{
					var name = $"{prefix}_{sortInfo.CompoundIndexName}";
					if (normalIndexes.TryGetValue(name, out var indexes))
						indexes.Add(attribute);
					else
						normalIndexes.Add(name, new List<AttributeInfo> { attribute });
				}
			});

			// prepare indexes of mappings
			definition.Attributes.Except(sortables).Where(attribute => attribute.IsMappings() || attribute.IsParentMapping()).ForEach(attribute =>
			{
				var name = $"{prefix}_{attribute.Name}";
				if (normalIndexes.TryGetValue(name, out var indexes))
					indexes.Add(attribute);
				else
					normalIndexes.Add(name, new List<AttributeInfo> { attribute });
			});

			// prepare indexes of alias
			definition.Attributes.Where(attribute => attribute.IsAlias()).ForEach(attribute =>
			{
				var aliasProps = attribute.GetCustomAttribute<AliasAttribute>().Properties.ToHashSet(",", true);
				var index = new[] { attribute, definition.Attributes.FirstOrDefault(attr => attr.Name.IsEquals("RepositoryEntityID")) }.Concat(definition.Attributes.Where(attr => aliasProps.Contains(attr.Name))).ToList();
				var name = $"{prefix}_Alias";
				if (uniqueIndexes.TryGetValue(name, out var indexes))
					indexes = indexes.Concat(index).ToList();
				else
					uniqueIndexes.Add(name, index);
			});

			// prepare full-text indexes
			var textIndexes = definition.Searchable
				? definition.Attributes.Where(attribute => attribute.IsSearchable()).Select(attribute => string.IsNullOrWhiteSpace(attribute.Column) ? attribute.Name : attribute.Column).ToList()
				: new List<string>();

			// get the collection
			var collection = NoSqlHelper.GetCollection<BsonDocument>(RepositoryMediator.GetConnectionString(dataSource), dataSource.DatabaseName, definition.CollectionName, true);

			// create indexes
			await normalIndexes.Where(kvp => kvp.Value.Count > 0).ForEachAsync(async kvp =>
			{
				IndexKeysDefinition<BsonDocument> index = null;
				TimeSpan? expireAfter = null;
				kvp.Value.ForEach(attribute =>
				{
					var sortInfo = attribute.GetCustomAttribute<SortableAttribute>();
					if (sortInfo != null)
					{
						index = index == null
							? sortInfo.Reverse ? Builders<BsonDocument>.IndexKeys.Descending(attribute.Name) : Builders<BsonDocument>.IndexKeys.Ascending(attribute.Name)
							: sortInfo.Reverse ? index.Descending(attribute.Name) : index.Ascending(attribute.Name);
						if (expireAfter == null && sortInfo.ExpireAfter > 0 && (string.IsNullOrWhiteSpace(sortInfo.CompoundIndexName) || !kvp.Key.IsEndsWith(sortInfo.CompoundIndexName)))
							expireAfter = TimeSpan.FromSeconds(sortInfo.ExpireAfter);
					}
				});
				if (index != null)
					try
					{
						await collection.Indexes.CreateOneAsync(new CreateIndexModel<BsonDocument>(index, new CreateIndexOptions { Name = kvp.Key, Background = true, ExpireAfter = expireAfter }), null, cancellationToken).ConfigureAwait(false);
						tracker?.Invoke($"Create index of No SQL successful => {kvp.Key}", null);
						if (tracker == null && RepositoryMediator.IsDebugEnabled)
							RepositoryMediator.WriteLogs($"Create index of No SQL successful => {kvp.Key}", null);
					}
					catch (Exception ex)
					{
						tracker?.Invoke($"Error occurred while creating index of No SQL => {ex.Message}", ex);
						RepositoryMediator.WriteLogs($"Error occurred while creating index of No SQL => {ex.Message}", ex, LogLevel.Error);
					}
			}, true, false).ConfigureAwait(false);

			await uniqueIndexes.Where(kvp => kvp.Value.Count > 0).ForEachAsync(async kvp =>
			{
				IndexKeysDefinition<BsonDocument> index = null;
				TimeSpan? expireAfter = null;
				kvp.Value.ForEach(attribute =>
				{
					var sortInfo = attribute.GetCustomAttribute<SortableAttribute>();
					if (sortInfo != null)
					{
						index = index == null
							? sortInfo.Reverse ? Builders<BsonDocument>.IndexKeys.Descending(attribute.Name) : Builders<BsonDocument>.IndexKeys.Ascending(attribute.Name)
							: sortInfo.Reverse ? index.Descending(attribute.Name) : index.Ascending(attribute.Name);
						if (expireAfter == null && sortInfo.ExpireAfter > 0)
							expireAfter = TimeSpan.FromSeconds(sortInfo.ExpireAfter);
					}
				});
				if (index != null)
					try
					{
						await collection.Indexes.CreateOneAsync(new CreateIndexModel<BsonDocument>(index, new CreateIndexOptions { Name = kvp.Key, Unique = true, Background = true, ExpireAfter = expireAfter }), null, cancellationToken).ConfigureAwait(false);
						tracker?.Invoke($"Create unique index of No SQL successful => {kvp.Key}", null);
						if (tracker == null && RepositoryMediator.IsDebugEnabled)
							RepositoryMediator.WriteLogs($"Create unique index of No SQL successful => {kvp.Key}", null);
					}
					catch (Exception ex)
					{
						tracker?.Invoke($"Error occurred while creating unique index of No SQL => {ex.Message}", ex);
						RepositoryMediator.WriteLogs($"Error occurred while creating unique index of No SQL => {ex.Message}", ex, LogLevel.Error);
					}
			}, true, false).ConfigureAwait(false);

			if (textIndexes.Count > 0)
			{
				IndexKeysDefinition<BsonDocument> index = null;
				textIndexes.ForEach(attribute =>
				{
					index = index == null
						? Builders<BsonDocument>.IndexKeys.Text(attribute)
						: index.Text(attribute);
				});
				try
				{
					await collection.Indexes.CreateOneAsync(new CreateIndexModel<BsonDocument>(index, new CreateIndexOptions { Name = $"{prefix}_Text_Search", Background = true }), null, cancellationToken).ConfigureAwait(false);
					tracker?.Invoke($"Create text index of No SQL successful => {prefix}_Text_Search", null);
					if (tracker == null && RepositoryMediator.IsDebugEnabled)
						RepositoryMediator.WriteLogs($"Create text index of No SQL successful => {prefix}_Text_Search", null);
				}
				catch (Exception ex)
				{
					tracker?.Invoke($"Error occurred while creating text index of No SQL => {ex.Message}", ex);
					RepositoryMediator.WriteLogs($"Error occurred while creating text index of No SQL => {ex.Message}", ex, LogLevel.Error);
				}
			}

			// create the blank document for ensuring the collection is created
			if (await collection.CountDocumentsAsync(Builders<BsonDocument>.Filter.Empty, null, cancellationToken).ConfigureAwait(false) < 1)
				try
				{
					var @object = definition.Type.CreateInstance() as RepositoryBase;
					@object.ID = UtilityService.BlankUUID;
					await collection.InsertOneAsync(@object.ToBsonDocument(), null, cancellationToken).ConfigureAwait(false);
					await Task.Delay(456, cancellationToken).ConfigureAwait(false);
					await collection.DeleteOneAsync(Builders<BsonDocument>.Filter.Eq("_id", UtilityService.BlankUUID), null, cancellationToken).ConfigureAwait(false);
				}
				catch (Exception ex)
				{
					tracker?.Invoke($"Error occurred while try to create blank document to eunsure index of No SQL => {ex.Message}", ex);
					RepositoryMediator.WriteLogs($"Error occurred while try to create blank document to eunsure index of No SQL => {ex.Message}", ex, LogLevel.Error);
				}
		}
		#endregion

	}

	#region Newtonsoft JSON Conversions
	public sealed class JTokenBsonSerializer : SerializerBase<JToken>
	{
		public override void Serialize(BsonSerializationContext context, BsonSerializationArgs args, JToken value)
			=> JTokenBsonSerializer.WriteJToken(context.Writer, value);

		static void WriteJToken(IBsonWriter writer, JToken token)
		{
			if (token == null || token.Type == JTokenType.Null)
			{
				writer.WriteNull();
				return;
			}

			switch (token.Type)
			{
				case JTokenType.Object:
					var obj = (JObject)token;
					writer.WriteStartDocument();
					foreach (var prop in obj.Properties())
					{
						writer.WriteName(prop.Name);
						JTokenBsonSerializer.WriteJToken(writer, prop.Value);
					}
					writer.WriteEndDocument();
					break;

				case JTokenType.Array:
					writer.WriteStartArray();
					foreach (var item in (JArray)token)
						JTokenBsonSerializer.WriteJToken(writer, item);
					writer.WriteEndArray();
					break;

				case JTokenType.Integer:
					writer.WriteInt64(token.Value<long>());
					break;

				case JTokenType.Float:
					writer.WriteDouble(token.Value<double>());
					break;

				case JTokenType.String:
					writer.WriteString(token.Value<string>());
					break;

				case JTokenType.Boolean:
					writer.WriteBoolean(token.Value<bool>());
					break;

				case JTokenType.Date:
					var dt = token.Value<DateTime>();
					writer.WriteDateTime(dt.ToUnixTimestamp());
					break;

				case JTokenType.Bytes:
					writer.WriteBytes(token.Value<byte[]>());
					break;

				case JTokenType.Guid:
					writer.WriteGuid(token.Value<Guid>());
					break;

				case JTokenType.Uri:
					writer.WriteString(token.Value<Uri>().ToString());
					break;

				case JTokenType.TimeSpan:
					writer.WriteInt64(token.Value<TimeSpan>().Ticks);
					break;

				case JTokenType.Undefined:
					writer.WriteUndefined();
					break;

				default:
					writer.WriteNull();
					break;
			}
		}

		public override JToken Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args)
		{
			var bsonValue = BsonValueSerializer.Instance.Deserialize(context, args);
			return JTokenBsonSerializer.BsonToJToken(bsonValue);
		}

		static JToken BsonToJToken(BsonValue bson)
		{
			if (bson == null || bson.IsBsonNull) return JValue.CreateNull();

			switch (bson.BsonType)
			{
				case BsonType.Document:
					var obj = new JObject();
					foreach (var elem in bson.AsBsonDocument)
						obj.Add(elem.Name, JTokenBsonSerializer.BsonToJToken(elem.Value));
					return obj;

				case BsonType.Array:
					var arr = new JArray();
					foreach (var item in bson.AsBsonArray)
						arr.Add(JTokenBsonSerializer.BsonToJToken(item));
					return arr;

				case BsonType.String:
					return new JValue(bson.AsString);

				case BsonType.Int32:
					return new JValue((long)bson.AsInt32);

				case BsonType.Int64:
					return new JValue(bson.AsInt64);

				case BsonType.Double:
					return new JValue(bson.AsDouble);

				case BsonType.Boolean:
					return new JValue(bson.AsBoolean);

				case BsonType.DateTime:
					return new JValue(bson.ToUniversalTime());

				case BsonType.Binary:
					return new JValue(bson.AsByteArray);

				case BsonType.ObjectId:
					return new JValue(bson.AsObjectId.ToString());

				case BsonType.Undefined:
					return JValue.CreateUndefined();

				default:
					return JValue.CreateNull();
			}
		}
	}
	#endregion

}