Foundation.Application.Contracts 1.1.0

Foundation.Application.Contracts

Application layer contracts for the Foundation framework, providing DTOs, interfaces, and CQRS contracts.

📦 Package Contents

This package provides the contracts for clean application architecture:

• DTOs: Data Transfer Objects for API requests/responses
• Commands: CQRS command contracts
• Queries: CQRS query contracts
• Service Interfaces: Application service contracts
• Common Contracts: Shared application interfaces (IUnitOfWork, IRepository, etc.)
• Validation Contracts: Input validation interfaces

🚀 Installation

dotnet add package Foundation.Application.Contracts

📖 Usage

DTOs (Data Transfer Objects)

Create request and response DTOs:

public record CreateProductRequest(
    string Name,
    string Description,
    decimal Price,
    int CategoryId
);

public record ProductDto(
    Guid Id,
    string Name,
    string Description,
    decimal Price,
    string CategoryName,
    DateTime CreatedAt
);

Command Contracts

Define commands for CQRS:

public record CreateProductCommand(
    string Name,
    string Description,
    decimal Price,
    int CategoryId
) : ICommand<ProductDto>;

public record UpdateProductCommand(
    Guid Id,
    string Name,
    string Description,
    decimal Price
) : ICommand;

Query Contracts

Define queries for CQRS:

public record GetProductByIdQuery(Guid Id) : IQuery<ProductDto>;

public record GetProductsQuery(
    int PageNumber = 1,
    int PageSize = 10,
    string? SearchTerm = null
) : IQuery<PagedResult<ProductDto>>;

Service Interfaces

Define application service contracts:

public interface IEmailService
{
    Task SendEmailAsync(EmailMessage message, CancellationToken cancellationToken = default);
    Task SendTemplatedEmailAsync<TModel>(
        string templateId, 
        string to, 
        TModel model, 
        CancellationToken cancellationToken = default);
}

public interface ICurrentUserService
{
    Guid UserId { get; }
    string Email { get; }
    IReadOnlyList<string> Roles { get; }
    bool IsAuthenticated { get; }
}

Repository Contracts

Define repository interfaces:

public interface IRepository<TEntity> where TEntity : BaseEntity
{
    Task<TEntity?> GetByIdAsync(Guid id, CancellationToken cancellationToken = default);
    Task<IReadOnlyList<TEntity>> GetAllAsync(CancellationToken cancellationToken = default);
    Task<TEntity> AddAsync(TEntity entity, CancellationToken cancellationToken = default);
    Task UpdateAsync(TEntity entity, CancellationToken cancellationToken = default);
    Task DeleteAsync(TEntity entity, CancellationToken cancellationToken = default);
    Task<IReadOnlyList<TEntity>> GetBySpecificationAsync(
        ISpecification<TEntity> specification, 
        CancellationToken cancellationToken = default);
}

Common Response Types

Standard response wrappers:

public record ApiResponse<T>(
    T? Data,
    bool IsSuccess,
    string? Message,
    IReadOnlyList<string>? Errors
);

public record PagedResult<T>(
    IReadOnlyList<T> Items,
    int TotalCount,
    int PageNumber,
    int PageSize
)
{
    public int TotalPages => (int)Math.Ceiling(TotalCount / (double)PageSize);
    public bool HasPreviousPage => PageNumber > 1;
    public bool HasNextPage => PageNumber < TotalPages;
}

🏗️ Architecture

This package follows Clean Architecture principles:

• No implementation details: Only contracts and DTOs
• Framework agnostic: Can be used with any DI container
• CQRS support: Clear command/query separation
• Testable: Interfaces enable easy mocking

📋 Requirements

• .NET 8.0 or higher
• Foundation.Domain.Models package

🤝 Contributing

This package is part of the Foundation framework. See the main repository for contribution guidelines.

📄 License

MIT License - see LICENSE file for details.