Nera.IAM.Common 1.0.0

Nera IAM Common

Common contracts, models, and protobuf definitions for Nera IAM Services.

Overview

This package provides shared contracts and models that enable loose coupling between IAM services while maintaining strong typing and consistent communication patterns.

Features

• Shared Enums: Common enumerations used across all IAM services
• Base Models: Response models, pagination, error handling
• Entity Models: User, Role, Permission, Token, Session, Organization models
• Service Contracts: Interfaces for inter-service communication
• Constants: Service names, cache keys, error codes, system roles/permissions
• Extensions: Utility methods for common operations
• gRPC Protobuf: Common message definitions for gRPC communication

Installation

<PackageReference Include="Nera.IAM.Common" Version="1.0.0" />

Usage

Service Contracts

Use the service contracts to communicate between IAM services:

public class AuthenticationService
{
    private readonly IUserServiceClient _userService;
    private readonly ITokenServiceClient _tokenService;
    
    public async Task<TokenInfo> AuthenticateAsync(string email, string password)
    {
        var user = await _userService.GetUserByEmailAsync(email);
        if (user?.Status.IsActive() == true)
        {
            var tokenId = await _tokenService.CreateTokenAsync(
                user.UserId, 
                user.OrgId, 
                TokenType.AccessToken, 
                TokenType.AccessToken.GetDefaultExpiration()
            );
            return await _tokenService.GetTokenAsync(tokenId);
        }
        throw new UnauthorizedAccessException();
    }
}

Common Models

Use shared models for consistent data structures:

public async Task<BaseResponse<UserInfo>> GetUserAsync(string userId)
{
    try
    {
        var user = await _repository.GetAsync(userId);
        return new BaseResponse<UserInfo>
        {
            Success = true,
            Data = user.ToUserInfo(),
            Message = "User retrieved successfully"
        };
    }
    catch (Exception ex)
    {
        return new BaseResponse<UserInfo>
        {
            Success = false,
            Message = ex.Message
        };
    }
}

Constants

Use predefined constants for consistency:

// Cache keys
var cacheKey = $"{IamConstants.CacheKeys.UserPrefix}{userId}";

// Service names for discovery
var serviceName = IamConstants.ServiceNames.UserService;

// Error codes
if (!user.Status.IsActive())
{
    throw new BusinessException(IamConstants.ErrorCodes.UserInactive);
}

// System roles
await _roleService.AssignRoleAsync(userId, IamConstants.SystemRoles.User);

Extensions

Use extension methods for common operations:

// Check if user is active
if (user.Status.IsActive())
{
    // Process active user
}

// Get default token expiration
var expiration = TokenType.AccessToken.GetDefaultExpiration();

// Check permission level
if (userPermission.AllowsAction(PermissionLevel.Write))
{
    // Allow write operation
}

Service Integration

This package enables clean service-to-service communication:

1. No Direct Dependencies: Services reference only this common package
2. Strong Typing: Type-safe contracts for all interactions
3. gRPC Support: Protobuf definitions for efficient communication
4. Consistent Patterns: Standardized request/response models

Architecture Benefits

• Loose Coupling: Services depend only on contracts, not implementations
• Consistency: Shared models ensure consistent data structures
• Maintainability: Centralized contracts make changes easier to manage
• Type Safety: Compile-time checking of service interactions
• Performance: Efficient gRPC communication with protobuf