Nera.Lib.Messaging.Abstractions 1.0.2

Nera.Lib.Messaging.Abstractions

Simplified Messaging Library for Nextera Services - Redesigned to be as simple as MediatR 🚀

Overview

A lightweight messaging library that provides two distinct messaging patterns for microservices:

• In-Service Events - Simple, MediatR-like events within the same service
• External Events - Cross-service messaging using MassTransit + RabbitMQ

Key Features

• ✅ Simple like MediatR - Familiar API for developers
• ✅ Auto-discovery - Automatic handler registration
• ✅ Proper lifetimes - Correct DI scoping
• ✅ Error isolation - One failing handler won't crash others
• ✅ Zero configuration - Works out of the box
• ✅ Type-safe - Full compile-time type checking

Quick Start

1. Install Package

<PackageReference Include="Nera.Lib.Messaging.Abstractions" Version="1.0.0" />

2. Register Services

// Program.cs or Startup.cs
services.AddMessagingServices(); // Enables in-service events

// Optional: Add MassTransit for external messaging
services.AddMassTransitWithRabbitMq(
    consumers => consumers.AddConsumer<MyConsumer>(),
    (cfg, ctx) => cfg.ReceiveEndpoint("my-queue", e => e.ConfigureConsumer<MyConsumer>(ctx))
);

3. Create Event & Handler

// Define an event
public class UserCreated : IInServiceEvent
{
    public string UserId { get; set; }
    public string Email { get; set; }
}

// Create a handler
public class SendWelcomeEmailHandler : IInServiceEventHandler<UserCreated>
{
    public async Task Handle(UserCreated @event, CancellationToken cancellationToken)
    {
        // Handle the event
        await SendWelcomeEmail(@event.Email);
    }
}

4. Publish Events

public class UserService
{
    private readonly IInServiceEventBus _eventBus;

    public async Task CreateUser(CreateUserRequest request)
    {
        var user = await CreateUserLogic(request);
        
        // Publish event - all handlers will be called automatically
        await _eventBus.Publish(new UserCreated 
        { 
            UserId = user.Id, 
            Email = user.Email 
        });
    }
}

Architecture

┌─────────────────────────────────────────────────────────────────┐
│                    Your Service                                 │
├─────────────────────────────────────────────────────────────────┤
│  In-Service Events (Fast, Same Process)                        │
│  ┌─────────────┐    ┌─────────────────────────────────────┐     │
│  │  Publisher  │───▶│  IInServiceEventBus                 │     │
│  └─────────────┘    │  ├─ Handler 1                       │     │
│                     │  ├─ Handler 2                       │     │
│                     │  └─ Handler N                       │     │
│                     └─────────────────────────────────────┘     │
├─────────────────────────────────────────────────────────────────┤
│  External Events (Reliable, Cross-Service)                     │
│  ┌─────────────┐    ┌─────────────────────────────────────┐     │
│  │  Publisher  │───▶│  MassTransit + RabbitMQ             │     │
│  └─────────────┘    └─────────────────────────────────────┘     │
└─────────────────────────────────────────────────────────────────┘
                                    │
                                    ▼
┌─────────────────────────────────────────────────────────────────┐
│                Other Services                                   │
│  ┌─────────────────────────────────────┐                       │
│  │  MassTransit Consumers              │                       │
│  │  ├─ Consumer 1                      │                       │
│  │  ├─ Consumer 2                      │                       │
│  │  └─ Consumer N                      │                       │
│  └─────────────────────────────────────┘                       │
└─────────────────────────────────────────────────────────────────┘

Comparison

Migration from Old Version

Before (Complex)

// Complex registration
services.AddInServiceEventHandlers(Assembly.GetExecutingAssembly());

// Manual handler registration with reflection issues
public class Handler : InServiceEventHandlerBase<Event>
{
    // Required specific base class
}

// Event with required properties
public class Event : InServiceEventBase
{
    public Guid Id { get; set; } // Required
    public DateTimeOffset OccurredOn { get; set; } // Required
}

After (Simple)

// Simple registration - auto-discovery
services.AddMessagingServices();

// Flexible handler implementation
public class Handler : IInServiceEventHandler<Event>
{
    // Or optionally inherit from base class for logging
}

// Simple event definition
public class Event : IInServiceEvent
{
    // Only your business properties
}

Documentation

• Detailed Usage Guide
• Bootstrap Examples
• Code Examples

Requirements

• .NET 9.0+
• MassTransit 8.0+ (for external events)
• RabbitMQ (for external events)

License

Internal Nextera library - Not for public distribution

Simple, Reliable, Type-Safe Messaging for Nextera Services 💪