Nabs.Launchpad.Core.SeedData 10.0.205

Nabs Launchpad Core Seed Data Library

A .NET 10 library providing interfaces and abstractions for database seeding and migration operations in the Nabs Launchpad framework.

Overview

The Nabs.Launchpad.Core.SeedData library defines core interfaces for managing database initialization tasks including:

• Database schema migrations
• Test data generation and seeding
• Development environment data setup

This library provides the contracts that implementations can use to handle database setup operations in a consistent manner across the Launchpad platform.

Key Features

• Migration Processing: Interface for handling database schema migrations
• Seed Data Processing: Interface for populating databases with initial or test data
• Seed Configuration Processing: Interface and helpers for seeding configuration into Azure App Configuration and the local emulator
• App Configuration Client Abstraction: Unified IConfgurationClient with Azure SDK and emulator implementations
• Automatic Registration: AddDataMigrationServices to wire up the correct configuration client based on connection string (Azure vs emulator)
• EF Migrations Helper: MigrationService.GenerateMigration<TContext> to generate migrations from the correct project folder
• Solution Path Discovery: PathFinder.FindSolutionFolder() for locating the solution root
• Async Support: All operations support cancellation tokens and async patterns
• Framework Integration: Designed to work seamlessly with dependency injection and hosted services

Core Interfaces and Components

ISeedDataProcessor

Defines a contract for processing seed data operations:

public interface ISeedDataProcessor
{
    Task ProcessAsync(CancellationToken stoppingToken);
}

Use this interface to implement classes that populate your database with:

• Initial application data
• Test data for development environments
• Sample data for demonstrations

IMigrationProcessor

Defines a contract for handling database migrations:

public interface IMigrationProcessor
{
    Task MigrateAsync(CancellationToken stoppingToken);
}

Use this interface to implement classes that:

• Apply database schema changes
• Execute migration scripts
• Ensure database schema is up-to-date

Additional Components

ISeedConfigurationProcessor

Defines a contract for seeding configuration (e.g., App Configuration keys/labels):

public interface ISeedConfigurationProcessor
{
    Task ProcessAsync(CancellationToken stoppingToken);
}

IConfgurationClient

Abstraction over Azure App Configuration operations with two implementations:

• AzureConfigurationClient (connection string or managed identity via URI)
• EmulatorConfigurationClient (HTTP REST for local emulator)

ProjectExtensions.AddDataMigrationServices

Registers the appropriate IConfgurationClient based on the App Configuration connection string:

builder.AddDataMigrationServices(appConfigurationName: "AppConfig");

• URI → Azure managed identity
• Full connection string → Azure SDK client
• localhost/127.0.0.1 → Emulator client

MigrationService.GenerateMigration

Helper to generate EF Core migrations from the correct project directory:

await dbContext.GenerateMigration("InitialCreate");

PathFinder.FindSolutionFolder

Utility to find the solution root to assist tooling that needs solution-relative paths.

Dependencies

• .NET 10: Target framework
• Bogus: Fake data generation library for creating realistic test data

Usage Examples

Implementing ISeedDataProcessor

public class UserSeedDataProcessor : ISeedDataProcessor
{
    private readonly IUserRepository _userRepository;
    private readonly Faker<User> _userFaker;

    public UserSeedDataProcessor(IUserRepository userRepository)
    {
        _userRepository = userRepository;
        _userFaker = new Faker<User>()
            .RuleFor(u => u.FirstName, f => f.Name.FirstName())
            .RuleFor(u => u.LastName, f => f.Name.LastName())
            .RuleFor(u => u.Email, f => f.Internet.Email());
    }

    public async Task ProcessAsync(CancellationToken stoppingToken)
    {
        if (await _userRepository.AnyAsync(stoppingToken))
            return; // Data already exists

        var users = _userFaker.Generate(100);
        await _userRepository.AddRangeAsync(users, stoppingToken);
    }
}

Implementing IMigrationProcessor

public class DatabaseMigrationProcessor : IMigrationProcessor
{
    private readonly ApplicationDbContext _context;

    public DatabaseMigrationProcessor(ApplicationDbContext context)
    {
        _context = context;
    }

    public async Task MigrateAsync(CancellationToken stoppingToken)
    {
        await _context.Database.MigrateAsync(stoppingToken);
    }
}

Dependency Injection Registration

services.AddScoped<ISeedDataProcessor, UserSeedDataProcessor>();
services.AddScoped<IMigrationProcessor, DatabaseMigrationProcessor>();

Using in Hosted Service

public class DatabaseInitializationService : IHostedService
{
    private readonly IMigrationProcessor _migrationProcessor;
    private readonly ISeedDataProcessor _seedDataProcessor;

    public DatabaseInitializationService(
        IMigrationProcessor migrationProcessor,
        ISeedDataProcessor seedDataProcessor)
    {
        _migrationProcessor = migrationProcessor;
        _seedDataProcessor = seedDataProcessor;
    }

    public async Task StartAsync(CancellationToken cancellationToken)
    {
        await _migrationProcessor.MigrateAsync(cancellationToken);
        await _seedDataProcessor.ProcessAsync(cancellationToken);
    }

    public Task StopAsync(CancellationToken cancellationToken) => Task.CompletedTask;
}

App Configuration Seeding and Registration

var builder = WebApplication.CreateBuilder(args);

// Registers IConfgurationClient (Azure vs Emulator) based on connection string
builder.AddDataMigrationServices(appConfigurationName: "AppConfig");

builder.Services.AddScoped<ISeedConfigurationProcessor, MyAppConfigSeeder>();

var app = builder.Build();

// Example seed processor
public sealed class MyAppConfigSeeder : ISeedConfigurationProcessor
{
    private readonly IConfgurationClient _client;
    public MyAppConfigSeeder(IConfgurationClient client) => _client = client;

    public async Task ProcessAsync(CancellationToken ct)
    {
        await _client.SetConfigurationSettingAsync(
            key: "MyApp:FeatureFlag:NewUI",
            value: "true",
            label: "prod",
            cancellationToken: ct);
    }
}

Using EmulatorConfigurationClient Directly (optional)

var client = new EmulatorConfigurationClient(
    connectionString: "Endpoint=http://localhost:8483;Id=...;Secret=...",
    httpClient: new HttpClient());
await client.AddConfigurationSettingAsync("Sample:Key", "value", label: "dev");

Generating EF Migrations

await using var context = new MyDbContext(options);
await context.GenerateMigration("InitialCreate");

Integration with Launchpad

This library is part of the larger Nabs Launchpad framework and integrates with:

• Core.Testing.Silos: Provides test data for Orleans silo testing
• Core.Persistence: Works with Entity Framework contexts for data operations
• Core.Context: Integrates with application database contexts

Best Practices

1. Environment-Specific Data: Only seed data appropriate for the current environment
2. Idempotent Operations: Ensure seed operations can be run multiple times safely
3. Performance Considerations: Use bulk operations for large datasets
4. Error Handling: Implement proper error handling and logging
5. Cancellation Support: Always respect cancellation tokens for graceful shutdowns

Testing

The library includes comprehensive unit tests in the Launchpad.Core.SeedData.UnitTests project to ensure reliability and correctness of the interfaces and any shared implementations.

Contributing

This library follows the Nabs Launchpad coding standards:

• Use C# 13 features and latest language constructs
• Follow nullable reference types conventions
• Implement proper async/await patterns
• Include comprehensive unit tests

License

Copyright � Net Advantage Business Solutions