TAF.Infra.Contract 1.10.11

TAF.Infra.Contract

A comprehensive contract library that provides common models, interfaces, and data structures for the TAF Infrastructure ecosystem. This package contains shared DTOs, enums, base classes, and contract definitions that ensure consistency across all TAF microservices and applications.

🚀 Features

• Shared Data Models: Common DTOs and data structures for inter-service communication
• Interface Contracts: Standardized interfaces for consistent service implementation
• Base Classes: Foundational classes for common patterns across services
• Enum Definitions: Standardized enumeration values for consistent data representation
• Type Safety: Strongly-typed contracts ensuring compile-time validation
• Cross-Service Consistency: Unified contracts across the entire TAF ecosystem

📦 Installation

dotnet add package TAF.Infra.Contract

🗃️ What's Included

Data Transfer Objects (DTOs)

• Common request/response models
• Shared data structures
• API contract definitions

Base Classes

• Base entity classes
• Common abstract classes
• Shared implementation patterns

Interfaces

• Service contract definitions
• Repository interfaces
• Common abstractions

Enumerations

• Status codes
• Type definitions
• Configuration constants

🚀 Quick Start

1. Installation

Add the package to your project:

dotnet add package TAF.Infra.Contract

2. Using Common Models

using TAF.Infra.Contract.Models;
using TAF.Infra.Contract.Enums;

// Use shared DTOs
public class UserService
{
    public async Task<UserDto> GetUserAsync(Guid userId)
    {
        // Implementation using common contract models
        return new UserDto
        {
            Id = userId,
            Status = UserStatus.Active
        };
    }
}

3. Implementing Common Interfaces

using TAF.Infra.Contract.Interfaces;

// Implement standardized interfaces
public class ProductRepository : IRepository<Product>
{
    public async Task<Product> GetByIdAsync(Guid id)
    {
        // Implementation
    }

    public async Task<IEnumerable<Product>> GetAllAsync()
    {
        // Implementation
    }
}

4. Using Base Classes

using TAF.Infra.Contract.Base;

// Extend from common base classes
public class Product : BaseEntity
{
    public string Name { get; set; }
    public decimal Price { get; set; }

    // BaseEntity provides: Id, CreatedAt, UpdatedAt, etc.
}

📚 Package Structure

Models

• BaseDto: Common properties for all DTOs
• ApiResponse<T>: Standardized API response wrapper
• PaginationRequest: Common pagination parameters
• PaginationResponse<T>: Paginated response structure

Enums

• ServiceStatus: Common service status values
• OperationResult: Standard operation result codes
• EntityState: Entity lifecycle states

Interfaces

• IRepository<T>: Generic repository pattern
• IService<T>: Common service interface
• IAuditable: Auditing interface for entities

Base Classes

• BaseEntity: Common entity base class with Id, timestamps
• BaseService: Common service implementation patterns
• BaseController: Standard API controller base

🛠️ Best Practices

Model Design

// Always inherit from base classes when appropriate
public class OrderDto : BaseDto
{
    public string OrderNumber { get; set; }
    public OrderStatus Status { get; set; }
    public List<OrderItemDto> Items { get; set; }
}

Interface Implementation

// Use common interfaces for consistency
public class OrderService : IOrderService
{
    public async Task<ApiResponse<OrderDto>> CreateOrderAsync(CreateOrderRequest request)
    {
        // Standardized response format
        return new ApiResponse<OrderDto>
        {
            Success = true,
            Data = createdOrder,
            Message = "Order created successfully"
        };
    }
}

Enum Usage

// Use shared enums for consistency across services
public class Order : BaseEntity
{
    public OrderStatus Status { get; set; } = OrderStatus.Pending;
    public PaymentStatus PaymentStatus { get; set; } = PaymentStatus.Unpaid;
}

🔧 Extending Contracts

Adding New Models

// Follow naming conventions
public class ProductDto : BaseDto
{
    public string Name { get; set; }
    public string Description { get; set; }
    public decimal Price { get; set; }
    public ProductCategory Category { get; set; }
}

Creating Custom Interfaces

// Extend base interfaces when needed
public interface IProductService : IService<Product>
{
    Task<IEnumerable<Product>> GetByCategoryAsync(ProductCategory category);
    Task<bool> UpdatePriceAsync(Guid productId, decimal newPrice);
}

🧪 Testing Support

The contract library provides:

• Mock-friendly interfaces
• Testable base classes
• Consistent data structures for unit tests

// Easy to mock standardized interfaces
var mockRepository = new Mock<IRepository<Product>>();
mockRepository.Setup(r => r.GetByIdAsync(It.IsAny<Guid>()))
              .ReturnsAsync(new Product { Name = "Test Product" });

📄 Version Compatibility

This package follows semantic versioning:

• Major: Breaking changes to contracts
• Minor: New models, interfaces, or enums (backward compatible)
• Patch: Bug fixes and documentation updates

🤝 Contributing

When adding new contracts:

1. Follow existing naming conventions
2. Add comprehensive documentation
3. Include usage examples
4. Ensure backward compatibility
5. Update version appropriately

📄 License

This project is licensed under the MIT License.

🐛 Issues

If you encounter any issues, please file them in the GitHub Issues section.

Built with ❤️ for consistent microservices architecture