Nedo.AspNet.Infrastructure 1.0.9

Nedo.AspNet.Infrastructure

A modular, production-ready infrastructure library for .NET 9 that standardizes integration with databases, message brokers, caches, and background services.

Features

• 🔌 Unified Connectivity — Standardized patterns for database, messaging, and caching
• 🗄️ Multi-Database — PostgreSQL, Oracle, MySQL, MariaDB, SQLite, InfluxDB, Qdrant
• 📨 Multi-Broker Messaging — RabbitMQ, NATS JetStream, MQTT, Redis Streams
• 💾 Distributed Caching — In-Memory, Redis, Valkey
• 💓 Health Checks — Fail-fast startup + HTTP liveness/readiness probes
• ⚙️ Background Processing — Work queues and scheduled jobs
• 📊 Observability — ActivitySource tracing + System.Diagnostics.Metrics
• 🏗️ Config Validation — Catch configuration errors at startup, not at 3 AM
• ✅ Testable — Interface-driven, easy to mock

Quick Start

dotnet add package Nedo.AspNet.Infrastructure

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddNedoInfrastructure(builder.Configuration, infra =>
{
    // Database
    infra.AddPostgreSQL();

    // Messaging (pick one)
    infra.AddRabbitMQ(msg =>
    {
        msg.AddConsumer<OrderCreated, OrderCreatedHandler>("orders.created");
    });

    // Caching (pick one)
    infra.AddRedisCache();
});

var app = builder.Build();

await app.RunStartupHealthChecksAsync();   // fail-fast if services unreachable
app.MapInfrastructureHealthChecks();       // HTTP health endpoints

app.Run();

Database

Providers

Configuration

{
  "Infrastructure": {
    "Database": {
      "Provider": "PostgreSQL",
      "Connection": {
        "Host": "localhost",
        "Port": 5432,
        "Database": "mydb",
        "Username": "user",
        "Password": "pass"
      },
      "CommandTimeout": 30
    }
  }
}

If both ConnectionString and Connection.* are set, ConnectionString takes priority.

Qdrant (Vector Database)

infra.AddQdrant(opts =>
{
    opts.Host = "localhost";
    opts.Port = 6334;
});

public class EmbeddingService(IQdrantVectorClient qdrant)
{
    public async Task IndexAsync(string id, float[] embedding)
    {
        var point = new PointStruct
        {
            Id = new PointId { Uuid = id },
            Vectors = embedding,
            Payload = { ["indexed_at"] = DateTimeOffset.UtcNow.ToString("O") }
        };

        await qdrant.UpsertAsync("documents", [point]);
    }

    public async Task<IReadOnlyList<ScoredPoint>> SearchAsync(float[] query)
    {
        return await qdrant.SearchAsync("documents", query, limit: 5);
    }
}

<details> <summary>Qdrant Configuration</summary>

{
  "Infrastructure": {
    "Database": {
      "Qdrant": {
        "Host": "localhost",
        "Port": 6334,
        "Https": false,
        "ApiKey": "",
        "DefaultCollection": "",
        "Timeout": "00:00:10"
      }
    }
  }
}

</details>

Messaging

Providers

Usage

Publish messages:

public class OrderService(IMessagePublisher publisher)
{
    public async Task CreateOrderAsync(Order order)
    {
        await _repo.SaveAsync(order);

        await publisher.PublishAsync(
            new OrderCreated(order.Id, order.Total),
            topic: "orders.created",
            properties: new MessageProperties
            {
                CorrelationId = Activity.Current?.Id,
                DeliveryMode = DeliveryMode.Persistent
            });
    }
}

Consume messages:

public record OrderCreated(Guid OrderId, decimal Total);

public class OrderCreatedHandler(ILogger<OrderCreatedHandler> logger)
    : IMessageConsumer<OrderCreated>
{
    public async Task<bool> HandleAsync(
        ConsumeContext<OrderCreated> context, CancellationToken ct = default)
    {
        logger.LogInformation("Order {Id}: ${Total}",
            context.Message.OrderId, context.Message.Total);

        // Process the order...

        return true;   // ack
        // return false; → nack / requeue
    }
}

Register consumers:

infra.AddRabbitMQ(msg =>
{
    msg.AddConsumer<OrderCreated, OrderCreatedHandler>("orders.created");
    msg.AddConsumer<PaymentReceived, PaymentHandler>("payments.received");
});

// Or with NATS JetStream:
infra.AddNatsJetStream(msg =>
{
    msg.AddConsumer<OrderCreated, OrderCreatedHandler>("APP.orders.created");
});

// Or with MQTT:
infra.AddMqtt(msg =>
{
    msg.AddConsumer<SensorReading, SensorHandler>("sensors/temperature");
});

// Or with Redis Streams:
infra.AddRedisStream(msg =>
{
    msg.AddConsumer<OrderCreated, OrderCreatedHandler>("orders.created");
});

Configuration

<details> <summary>RabbitMQ</summary>

{
  "Infrastructure": {
    "Messaging": {
      "Enabled": true,
      "Provider": "RabbitMQ",
      "HostName": "localhost",
      "Port": 5672,
      "Username": "guest",
      "Password": "guest",
      "Exchange": { "Name": "app.events", "Type": "topic", "Durable": true },
      "Consumer": { "PrefetchCount": 10, "RetryCount": 3 },
      "DeadLetter": { "Enabled": true, "Exchange": "app.deadletter", "MaxRetries": 5 }
    }
  }
}

</details>

<details> <summary>NATS JetStream</summary>

{
  "Infrastructure": {
    "Messaging": {
      "Enabled": true,
      "Provider": "NatsJetStream",
      "Nats": {
        "Url": "nats://localhost:4222",
        "StreamName": "APP",
        "DurableName": "app-worker",
        "AckWait": "00:00:30",
        "MaxDeliver": 5
      }
    }
  }
}

</details>

<details> <summary>MQTT</summary>

{
  "Infrastructure": {
    "Messaging": {
      "Enabled": true,
      "Provider": "MQTT",
      "Mqtt": {
        "BrokerHost": "localhost",
        "BrokerPort": 1883,
        "ClientId": "myapp-worker",
        "CleanSession": true,
        "DefaultQoS": 1,
        "UseTls": false
      }
    }
  }
}

</details>

<details> <summary>Redis Streams</summary>

{
  "Infrastructure": {
    "Messaging": {
      "Enabled": true,
      "Provider": "RedisStream",
      "RedisStream": {
        "ConnectionString": "localhost:6379",
        "StreamPrefix": "messaging",
        "ConsumerGroup": "app-workers",
        "ConsumerName": "worker-1",
        "ReadBatchSize": 10,
        "MaxStreamLength": 0
      }
    }
  }
}

</details>

Caching

Providers

Usage

public class ProductService(ICacheProvider cache, IProductRepo repo)
{
    public async Task<Product?> GetAsync(int id, CancellationToken ct)
    {
        return await cache.GetOrCreateAsync(
            key: $"products:{id}",
            factory: async ct => await repo.FindByIdAsync(id, ct),
            options: new CacheEntryOptions
            {
                AbsoluteExpiration = TimeSpan.FromMinutes(30),
                Tags = ["products"]
            },
            ct: ct);
    }

    public async Task InvalidateCategoryAsync(CancellationToken ct)
    {
        await cache.RemoveByTagAsync("products", ct);
    }
}

Configuration

{
  "Infrastructure": {
    "Cache": {
      "Enabled": true,
      "ConnectionString": "localhost:6379",
      "KeyPrefix": "myapp:",
      "DefaultExpiration": "01:00:00"
    }
  }
}

Health Checks

var app = builder.Build();

await app.RunStartupHealthChecksAsync();  // fail-fast if DB/cache/broker unreachable
app.MapInfrastructureHealthChecks();      // HTTP endpoints

All registered providers (database, messaging, caching) automatically contribute health checks.

Observability

Every module emits structured tracing and metrics:

Documentation

Full documentation in docs/:

Project Structure

├── docs/                           # Documentation (by topic)
├── sample/                         # Sample projects
├── src/Nedo.AspNet.Infrastructure/
│   ├── Builder/                    # DI builder & extensions
│   ├── Configuration/              # Strongly-typed options
│   ├── Core/                       # Connection factory & pooling
│   ├── Database/                   # PostgreSQL, Oracle, MySQL, MariaDB, SQLite
│   │   ├── InfluxDb/              # Time-series database
│   │   └── Qdrant/                # Vector database
│   ├── Messaging/
│   │   ├── RabbitMQ/              # AMQP provider
│   │   ├── NatsJetStream/         # NATS provider
│   │   ├── Mqtt/                  # MQTT provider
│   │   └── RedisStream/           # Redis Streams provider
│   ├── Caching/
│   │   └── Redis/                 # Redis/Valkey provider
│   ├── HealthChecks/
│   ├── Observability/
│   └── BackgroundProcessing/
├── test/                           # Unit tests (102 passing)
├── .gitlab-ci.yml
└── README.md

Build & Test

dotnet build
dotnet test    # 102 tests

Releasing

1. Tag: git tag v1.0.0
2. Push: git push origin v1.0.0
3. GitLab CI builds, packs, and publishes to NuGet.

Requires: NUGET_API_KEY CI/CD variable.

License

MIT License