Indiko.Blocks.DataAccess.MongoDb 2.1.2

Indiko.Blocks.DataAccess.MongoDb

MongoDB implementation of the Indiko data access abstractions, providing NoSQL document database support with full repository pattern.

Overview

This package provides a complete MongoDB implementation of the Indiko data access layer, supporting document-based data storage, indexing, aggregations, and transactions.

Features

• MongoDB Driver: Full MongoDB.Driver integration
• Repository Implementation: Complete IRepository<TEntity, TIdType> implementation
• Document Storage: Native document/BSON support
• Indexing: Attribute-based and fluent index configuration
• Aggregation Pipeline: Support for MongoDB aggregation framework
• Transactions: Multi-document ACID transactions
• Change Streams: Real-time change notification support
• GridFS: Large file storage support
• Flexible Schema: Schema-less document storage
• High Performance: Optimized for MongoDB operations

Installation

dotnet add package Indiko.Blocks.DataAccess.MongoDb

Quick Start

Define Your DbContext

using Indiko.Blocks.DataAccess.MongoDb;

public class AppDbContext : BaseDbContext
{
    public AppDbContext(IMongoDatabase database) : base(database)
    {
    }

    public IMongoCollection<User> Users => GetCollection<User>();
    public IMongoCollection<Order> Orders => GetCollection<Order>();

    protected override void OnModelCreating(MongoModelBuilder modelBuilder)
    {
        base.OnModelCreating(modelBuilder);
        
        // Configure collections
        modelBuilder.Entity<User>(entity =>
        {
            entity.ToCollection("users");
            entity.HasIndex(u => u.Email, unique: true);
        });

        modelBuilder.Entity<Order>(entity =>
        {
            entity.ToCollection("orders");
            entity.HasIndex(o => o.OrderNumber, unique: true);
            entity.HasIndex(o => o.UserId);
        });
    }
}

Configure Services

public class Startup : WebStartup
{
    public override void ConfigureServices(IServiceCollection services)
    {
        base.ConfigureServices(services);
        
        services.UseMongoDbDataAccess<AppDbContext>(options =>
        {
            options.ConnectionString = Configuration.GetConnectionString("MongoDB");
            options.DatabaseName = "MyAppDb";
        });
    }
}

Entity Definition

using MongoDB.Bson;
using MongoDB.Bson.Serialization.Attributes;

public class User : BaseEntity<ObjectId>
{
    [BsonElement("name")]
    public string Name { get; set; }
    
    [BsonElement("email")]
    public string Email { get; set; }
    
    [BsonElement("age")]
    public int Age { get; set; }
    
    [BsonElement("tags")]
    public List<string> Tags { get; set; }
    
    [BsonElement("metadata")]
    public Dictionary<string, object> Metadata { get; set; }
    
    [BsonDateTimeOptions(Kind = DateTimeKind.Utc)]
    public DateTime BirthDate { get; set; }
}

Usage Examples

Basic CRUD

public class UserService
{
    private readonly IRepository<User, ObjectId> _userRepository;
    private readonly IUnitOfWork _unitOfWork;

    public UserService(IRepository<User, ObjectId> userRepository, IUnitOfWork unitOfWork)
    {
        _userRepository = userRepository;
        _unitOfWork = unitOfWork;
    }

    public async Task<User> CreateAsync(User user)
    {
        user.Id = ObjectId.GenerateNewId();
        await _userRepository.AddAsync(user);
        await _unitOfWork.SaveChangesAsync();
        return user;
    }

    public async Task<User> GetByIdAsync(ObjectId id)
    {
        return await _userRepository.ReadByIdAsync(id);
    }

    public async Task<IEnumerable<User>> SearchByNameAsync(string name)
    {
        return await _userRepository.ReadManyByQueryAsync(u => 
            u.Name.Contains(name, StringComparison.OrdinalIgnoreCase));
    }
}

MongoDB-Specific Queries

// Array contains
var usersWithTag = await _userRepository.ReadManyByQueryAsync(u => 
    u.Tags.Contains("premium"));

// Nested property queries
var activeAdults = await _userRepository.ReadManyByQueryAsync(u => 
    u.Age >= 18 && u.Status == Status.Active);

// Regular expressions
var emailPattern = new BsonRegularExpression("@gmail\\.com$", "i");
var gmailUsers = await _userRepository.AsQueryable()
    .Where(u => u.Email.Matches(emailPattern))
    .ToListAsync();

// GeoSpatial queries (if using geo indexes)
var nearbyUsers = await _userRepository.AsQueryable()
    .Where(u => u.Location.Near(longitude, latitude, maxDistance))
    .ToListAsync();

Indexing

Attribute-Based Indexing

using Indiko.Blocks.DataAccess.MongoDb.Attributes;

public class Product : BaseEntity<ObjectId>
{
    [MongoIndex(Unique = true)]
    public string SKU { get; set; }
    
    [MongoIndex]
    public string Category { get; set; }
    
    [MongoIndex(Name = "price_index", Order = -1)]
    public decimal Price { get; set; }
    
    // Compound index
    [MongoIndex(Name = "category_price", Order = 1, CompoundWith = nameof(Price))]
    public string CategoryForCompound { get; set; }
}

Fluent Index Configuration

protected override void OnModelCreating(MongoModelBuilder modelBuilder)
{
    modelBuilder.Entity<Product>(entity =>
    {
        entity.ToCollection("products");
        
        // Simple index
        entity.HasIndex(p => p.SKU, unique: true);
        
        // Compound index
        entity.HasIndex(
            p => new { p.Category, p.Price },
            name: "category_price_idx"
        );
        
        // Text index for full-text search
        entity.HasTextIndex(p => p.Description);
        
        // TTL index (auto-delete after expiration)
        entity.HasTTLIndex(p => p.ExpiresAt, expireAfterSeconds: 0);
    });
}

Aggregation Pipeline

// Using AsQueryable for aggregation
var topCategories = await _productRepository.AsQueryable()
    .GroupBy(p => p.Category)
    .Select(g => new 
    {
        Category = g.Key,
        Count = g.Count(),
        TotalRevenue = g.Sum(p => p.Price),
        AvgPrice = g.Average(p => p.Price)
    })
    .OrderByDescending(x => x.Count)
    .Take(10)
    .ToListAsync();

// Native aggregation pipeline
var collection = _context.GetCollection<Order>();
var pipeline = new[]
{
    new BsonDocument("$match", new BsonDocument("status", "completed")),
    new BsonDocument("$group", new BsonDocument
    {
        { "_id", "$userId" },
        { "totalOrders", new BsonDocument("$sum", 1) },
        { "totalAmount", new BsonDocument("$sum", "$amount") }
    }),
    new BsonDocument("$sort", new BsonDocument("totalAmount", -1)),
    new BsonDocument("$limit", 10)
};

var results = await collection.AggregateAsync<BsonDocument>(pipeline);

Transactions

public async Task TransferInventoryAsync(ObjectId fromWarehouseId, ObjectId toWarehouseId, string productId, int quantity)
{
    await _unitOfWork.BeginTransactionAsync();
    
    try
    {
        var warehouseRepo = _manager.GetRepository<Warehouse, ObjectId>();
        
        var fromWarehouse = await warehouseRepo.ReadByIdAsync(fromWarehouseId);
        var toWarehouse = await warehouseRepo.ReadByIdAsync(toWarehouseId);
        
        fromWarehouse.Inventory[productId] -= quantity;
        toWarehouse.Inventory[productId] += quantity;
        
        await warehouseRepo.UpdateAsync(fromWarehouse);
        await warehouseRepo.UpdateAsync(toWarehouse);
        
        await _unitOfWork.SaveChangesAsync();
        await _unitOfWork.CommitTransactionAsync();
    }
    catch
    {
        await _unitOfWork.RollbackTransactionAsync();
        throw;
    }
}

Change Streams

public async Task WatchForChangesAsync(CancellationToken cancellationToken)
{
    var collection = _context.GetCollection<User>();
    
    var pipeline = new EmptyPipelineDefinition<ChangeStreamDocument<User>>()
        .Match(change => change.OperationType == ChangeStreamOperationType.Insert ||
                        change.OperationType == ChangeStreamOperationType.Update);
    
    using var cursor = await collection.WatchAsync(pipeline, cancellationToken: cancellationToken);
    
    await cursor.ForEachAsync(change =>
    {
        Console.WriteLine($"Change detected: {change.OperationType}");
        Console.WriteLine($"Document: {change.FullDocument.Name}");
    }, cancellationToken);
}

Configuration

appsettings.json

{
  "ConnectionStrings": {
    "MongoDB": "mongodb://localhost:27017"
  },
  "MongoDb": {
    "DatabaseName": "MyAppDb",
    "MaxConnectionPoolSize": 500,
    "MinConnectionPoolSize": 10,
    "ConnectTimeout": "30s",
    "SocketTimeout": "30s",
    "ServerSelectionTimeout": "30s",
    "RetryWrites": true,
    "RetryReads": true
  }
}

Code Configuration

services.UseMongoDbDataAccess<AppDbContext>(options =>
{
    options.ConnectionString = "mongodb://localhost:27017";
    options.DatabaseName = "MyAppDb";
    options.MaxConnectionPoolSize = 500;
    options.EnableQueryLogging = env.IsDevelopment();
});

Best Practices

Use ObjectId for Primary Keys

public class MyEntity : BaseEntity<ObjectId>
{
    // ObjectId is optimized for MongoDB
}

Embed Related Data for Read Performance

public class Order : BaseEntity<ObjectId>
{
    public ObjectId UserId { get; set; }
    
    // Embedded document for better read performance
    public UserInfo UserInfo { get; set; }
    
    public List<OrderItem> Items { get; set; }
}

public class UserInfo
{
    public string Name { get; set; }
    public string Email { get; set; }
}

Use Projections

// Only retrieve needed fields
var userNames = await _userRepository.ReadByQueryWithSelectorAsync(
    where: u => u.IsActive,
    selector: u => new { u.Id, u.Name }
);

Create Appropriate Indexes

// Index frequently queried fields
entity.HasIndex(u => u.Email, unique: true);
entity.HasIndex(u => u.CreatedAt);
entity.HasIndex(u => new { u.Category, u.Status });

MongoDB-Specific Features

Document Validation

var validator = new BsonDocument("$jsonSchema", new BsonDocument
{
    { "bsonType", "object" },
    { "required", new BsonArray { "name", "email" } },
    { "properties", new BsonDocument
        {
            { "name", new BsonDocument("bsonType", "string") },
            { "email", new BsonDocument
                {
                    { "bsonType", "string" },
                    { "pattern", "^.+@.+$" }
                }
            }
        }
    }
});

GridFS for Large Files

public class FileService
{
    private readonly IGridFSBucket _gridFS;

    public async Task<ObjectId> UploadFileAsync(Stream fileStream, string filename)
    {
        return await _gridFS.UploadFromStreamAsync(filename, fileStream);
    }

    public async Task<byte[]> DownloadFileAsync(ObjectId fileId)
    {
        return await _gridFS.DownloadAsBytesAsync(fileId);
    }
}

Target Framework

• .NET 10

Dependencies

• Indiko.Blocks.DataAccess.Abstractions
• MongoDB.Driver (2.28+)
• MongoDB.Bson

License

See LICENSE file in the repository root.

Related Packages

• Indiko.Blocks.DataAccess.Abstractions - Core data access abstractions
• Indiko.Blocks.DataAccess.EntityFramework - EF Core implementation
• Indiko.Blocks.DataAccess.Marten - Marten implementation