Microservice.Api 1.0.23

About

Microservice.Api is a .NET library that provides a set of common services and utilities for building microservices. It includes features such as logging, configuration management, dependency injection, and more.

How to Use

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddMicroservice();

var app = builder.Build();
app.UseMicroservice();

app.Run();

To create a role provider, you can implement the IRoleProvider interface and define your methods for retrieving roles. Here's an example of a role provider that retrieves roles from a database and caches them using a hybrid cache:

1. On app startup, the application scans the request handler and automatically registers it.
2. Middleware scans the role provider to retrieve roles for a given user ID and adds them to the claims.
3. Role provider used for authentication and authorization in the microservice. It retrieves roles from a database and caches them using a hybrid cache.
4. Microservice.Security namespace provides the necessary interfaces and classes for implementing role providers.

using Microservice.Security;

class DbRoleProvider(HybridCache cache): CachedRoleProvider("DB role provider", cache) {
	protected Task<IReadOnlyCollection<string>> GetRolesAsync(string? userId, CancellationToken cancellationToken = default) {
		return Task.FromResult<IReadOnlyCollection<string>>(new List<string> { "Admin", "User" });
	}
}

Create entity

using Microservice.Data;

[Database(DatabaseProvider.PostgreSql, ConnectionName = "DefaultConnection")]
public class MyEntity : IEntity<Guid>
{
	[Key(IsAutoGenerated = true)]
	public Guid Id { get; set; }
    public string Name { get; set; } = null!;
    public string? Description { get; set; }
	[CreatedBy]
    public Guid? CreatedBy { get; set; }
    [CreatedAt]
    public DateTime CreatedAt { get; set; }
    [LastModifiedBy]
    public Guid? LastModifiedBy { get; set; }
    [LastModifiedAt]
    public DateTime LastModifiedAt { get; set; }
    [DeletedBy]
    public Guid? DeletedBy { get; set; }
    [DeletedAt]
    public DateTime? DeletedAt { get; set; }
}

To create a request handler, you can implement the IRequestHandler interface and define your methods for handling requests. Here's an example of a request handler that uses a repository factory to perform search and add operations:

1. On app startup, the application scans the request handler and automatically registers it.
2. The request handler is responsible for processing incoming requests and returning appropriate responses.

using Microservice.Api;
using Microservice.Data;
using Microservice.Models;

class MyRequestHandler(IRepositoryFactory repositoryFactory) : IRequestHandler
{
	public async Task<SearchResult<MyModel>> SearchAsync(Searchable request, CancellationToken cancellationToken)
	{
        var repos = repositoryFactory.Create<MyEntity, Guid>();
		var results = await repos.SearchAsync<MyModel>(request, cancellationToken: cancellationToken);
		return results;
	}

	public async Task<Guid> AddAsync(MyFormModel request, CancellationToken cancellationToken)
	{
        var repos = repositoryFactory.Create<MyEntity, Guid>();
		var id = await repos.AddAsync<MyModel>(request, cancellationToken: cancellationToken);
		return id;
	}
}

To create an endpoint, you can implement the IEndpoint interface and define your routes and handlers. Here's an example of an endpoint that maps a GET request to a search method and a POST request to an add method:

1. On app startup, the application scans the endpoint and automatically registers it.

using Microservice.Api;

class MyEndpoint : IEndpoint
{
    public void MapEndpoint(IEndpointRouteBuilder app)
    {
        app.MapPost("/my-endpoint/search", (Searchable request, MyRequestHandler handler, CancellationToken cancellationToken) => handler.Me(request, cancellationToken));
        app.MapPost("/my-endpoint", (MyFormModel request, MyRequestHandler handler, CancellationToken cancellationToken) => handler.AddAsync(request, cancellationToken)).RequireAuthorization();
    }
}

To create a model validator, you can implement the AbstractValidator<T> class from the FluentValidation library and define your validation rules. Here's an example of a model validator that validates a form model:

1. On app startup, the application scans the model validator and automatically registers it.
2. The model validator is responsible for validating incoming requests and returning appropriate error messages.

class MyFormModelValidator : AbstractValidator<MyFormModel>
{
	public MyFormModelValidator()
	{
		RuleFor(x => x.Name).NotEmpty().WithMessage("Name is required.");
		RuleFor(x => x.Age).GreaterThan(0).WithMessage("Age must be greater than 0.");
	}
}

To using transaction, you can use the IUnitOfWork interface to perform database operations within a transaction. Here's an example of how to use transactions in a request handler:

1. IUnitOfWorkFactory is used to create a unit of work for a specific entity type.
2. The IUnitOfWork interface provides methods for creating repositories for different entity types, allowing you to perform operations on multiple entities within the same transaction.
3. The StartAsync method is called to begin the transaction.
4. The CommitAsync method is called to commit the transaction after all operations are completed successfully.
5. If any operation fails, the transaction will be rolled back automatically when the unit of work is disposed.
6. You can also manually roll back the transaction using the RollbackAsync method.

using Microservice.Api;
using Microservice.Data;
using Microservice.Models;

class MyRequestHandler(IUnitOfWorkFactory unitOfWorkFactory) : IRequestHandler
{
	public async Task<Guid> AddAsync(MyFormModel request, CancellationToken cancellationToken)
	{
		await using var unitOfWork = unitOfWorkFactory.Create<MyEntity>();
		await unitOfWork.StartAsync(ct: cancellationToken);
        var myRepos = unitOfWork.GetRepository<MyEntity, Guid>();
        var logRepos = unitOfWork.GetRepository<LogEntity, Guid>();
		var id = await myRepos.AddAsync<MyModel>(request, cancellationToken: cancellationToken);
		await logRepos.AddAsync(new LogEntity { Message = $"Added entity with ID: {id}" }, cancellationToken: cancellationToken);
		await unitOfWork.CommitAsync(cancellationToken);
		return id;
	}
}

Notice: IUnitOfWorkFactory.Create<T>() parameter T must be an entity class that is decorated with the [Database] attribute, which specifies the database provider and connection name. The IUnitOfWork instance created by the factory will manage the transaction for that specific entity type and its associated database connection.