Osirion.Blazor.Cms.Infrastructure 4.0.0

Osirion.Blazor.Cms.Infrastructure

Infrastructure layer for the Osirion.Blazor CMS ecosystem, implementing repositories, external service integrations, and infrastructure concerns.

Overview

The Infrastructure project implements the Infrastructure layer in the Clean Architecture pattern, providing concrete implementations of the interfaces defined in the Domain and Application layers. It includes repositories, API clients, storage implementations, and external service integrations.

Features

• GitHub Provider: Content repository implementation using GitHub API
• File System Provider: Local file system content repository
• Caching Integration: Memory and distributed cache implementations
• HTTP Clients: Typed HTTP clients for external service communication
• Local Storage: Browser local storage adapter for client-side persistence
• Dependency Injection: Infrastructure service registration extensions

GitHub Provider

Content provider implementation using the GitHub API via Octokit.NET:

public class GitHubContentRepository : IContentRepository
{
    private readonly GitHubClient _client;
    private readonly IMemoryCache _cache;
    private readonly ILogger<GitHubContentRepository> _logger;
    private readonly GitHubContentOptions _options;

    public GitHubContentRepository(
        IHttpClientFactory httpClientFactory,
        IMemoryCache cache,
        IOptions<GitHubContentOptions> options,
        ILogger<GitHubContentRepository> logger)
    {
        _cache = cache;
        _logger = logger;
        _options = options.Value;
        
        _client = new GitHubClient(new ProductHeaderValue("Osirion.Blazor.Cms"));
        
        if (!string.IsNullOrWhiteSpace(_options.PersonalAccessToken))
        {
            _client.Credentials = new Credentials(_options.PersonalAccessToken);
        }
    }

    public async Task<ContentItem?> GetByPathAsync(string path)
    {
        try
        {
            var cacheKey = $"github:content:{path}";
            
            if (_cache.TryGetValue(cacheKey, out ContentItem? cachedItem))
            {
                return cachedItem;
            }
            
            var contentResponse = await _client.Repository.Content.GetAllContents(
                _options.Owner, 
                _options.Repository,
                Path.Combine(_options.ContentPath, path));
                
            var content = contentResponse.FirstOrDefault();
            
            if (content is null)
            {
                return null;
            }
            
            var decodedContent = content.Encoding == ContentEncoding.Base64
                ? Encoding.UTF8.GetString(Convert.FromBase64String(content.Content))
                : content.Content;
                
            var contentItem = await ProcessContentAsync(path, decodedContent);
            
            var cacheOptions = new MemoryCacheEntryOptions()
                .SetSlidingExpiration(TimeSpan.FromMinutes(_options.CacheExpirationMinutes));
                
            _cache.Set(cacheKey, contentItem, cacheOptions);
            
            return contentItem;
        }
        catch (NotFoundException)
        {
            _logger.LogWarning("Content not found in GitHub repository: {Path}", path);
            return null;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error fetching content from GitHub: {Path}", path);
            throw;
        }
    }
    
    // Additional repository methods
}

Configuration Options

Configuration options for the infrastructure providers:

public class GitHubContentOptions
{
    public string Owner { get; set; } = string.Empty;
    public string Repository { get; set; } = string.Empty;
    public string Branch { get; set; } = "main";
    public string ContentPath { get; set; } = "content";
    public string? PersonalAccessToken { get; set; }
    public bool UseCache { get; set; } = true;
    public int CacheExpirationMinutes { get; set; } = 60;
}

public class FileSystemContentOptions
{
    public string BasePath { get; set; } = "content";
    public bool WatchForChanges { get; set; } = false;
    public bool UseCache { get; set; } = true;
    public int CacheExpirationMinutes { get; set; } = 60;
}

GitHub API Clients and Credentials

• IGitHubApiClientFactory.GetClient(name) and GetDefaultClient() return a new GitHubApiClient on every call. The caller owns it: SetRepository, SetBranch and SetAccessToken change that instance only and never another caller's client.
• A client sends Accept, User-Agent and Authorization on each request message and never changes HttpClient.DefaultRequestHeaders. An Accept or User-Agent header you configure on the HttpClient is kept.
• Factory clients take a short-lived HttpClient named GitHub_{ProviderName} from IHttpClientFactory for every operation. Configure it with services.AddHttpClient("GitHub_Blog").
• Cookies are turned off on the primary handler of the GitHub_*, IGitHubApiClient, IGitHubTokenProvider and IAuthenticationService clients, because a pooled handler is shared by every user. The policy runs after all handler configuration, so a primary handler you configure (through ConfigureHttpClientDefaults or the named client, before or after the Osirion registration) is kept with cookies turned off. In the browser it does nothing, because the fetch API owns cookies there.
• Repository paths, branch names, owner and repository are percent-encoded per segment. A backslash in a repository path is read as a / separator. A path or branch name with an empty, . or .. segment is rejected with an ArgumentException before any request is sent. URLs built from letters, digits, -, _, ., ~ and / are unchanged.
• IAuthenticationService and IGitHubAdminService are registered as scoped, one per circuit or request, replacing any earlier registration. The admin service never uses a content provider's ApiToken: it uses the signed-in user's token, or CmsAdminOptions.Authentication.PersonalAccessToken when one is configured. Without either, repository operations send no request; DeleteFileAsync, for example, throws InvalidOperationException instead of sending an unauthenticated delete. Signing out drops the user's token from the admin service of the same scope.
• AuthenticationService keeps the user's token in memory only. It never writes the token to IStateStorageService (which stores plain text) and never signs anyone in with the configured PersonalAccessToken. InitializeAsync and sign-out remove a github_auth_token value that earlier versions left in browser storage. The admin module keeps a signed-in user's token between page loads in encrypted, user-bound protected browser storage instead.
• GitHubTokenProvider requests Accept: application/json, sends the redirect_uri and PKCE code_verifier it is given, treats an error field in a 200 response as a rejected exchange, and honours its CancellationToken. The original ExchangeCodeForTokenAsync(code, clientId, clientSecret) overload still works and sends neither value.

Dependencies

The infrastructure layer has the following dependencies:

• Osirion.Blazor.Cms.Domain: For domain entities and interfaces
• Osirion.Blazor.Cms.Application: For application services and interfaces
• Octokit: For GitHub API integration
• Blazored.LocalStorage: For browser local storage access
• Microsoft.Extensions.Caching.Memory: For memory caching
• Microsoft.Extensions.Http: For HTTP client factory

License

This project is licensed under the MIT License - see the LICENSE file for details.