Infrastructure,
Simplified.

public static InvoiceEntity ApplyInvoiceKeyTemplates(
    this InvoiceEntity entity)
{
    if (string.IsNullOrEmpty($"{entity.PartitionKey}"))
        entity.PartitionKey = $"Invoices#{entity.InvoiceId}";

    if (string.IsNullOrEmpty($"{entity.SortKey}"))
        entity.SortKey = "Details";

    return entity;
}

// At the call site, the keys are never mentioned:
// repo.InsertAsync(new InvoiceEntity { InvoiceId = id });

// Read: DynamoDB attribute map to entity
if (attribute.TryGetValue("InvoiceId", out var av_InvoiceId)
    && av_InvoiceId is not null && av_InvoiceId.NULL != true)
{
    var av = av_InvoiceId;
    entity.InvoiceId = Guid.Parse(av.S);
}

// Write: entity to DynamoDB attribute map
__r["InvoiceId"] = new AttributeValue { S = entity.InvoiceId.ToString() };

public static QueryConfigOption<InvoiceEntity> FilterByStatus(
    this QueryConfigOption<InvoiceEntity> queryConfig,
    InvoiceStatus value, bool overwrite = false)
{
    if (overwrite)
        queryConfig.Config.FilterExpressions.RemoveExpression("Status");

    var expression = (QueryOperator.Equal, value);

    queryConfig.Config.AddFilterExpression<InvoiceEntity, InvoiceStatus>(
        entity => entity.Status, expression);
    return queryConfig;
}

// At the call site:
// repo.FindInvoiceAsync(invoiceId,
//     o => o.FilterByStatus(InvoiceStatus.Paid));

public partial class InvoiceRepository
    : Repository<InvoiceEntity>, IInvoiceRepository
{
    public Task<InvoiceEntity?> FindInvoiceAsync(Guid invoiceId,
        bool isConsistentRead = true, QueryConfig? queryConfig = null)
    {
        queryConfig ??= QueryConfigInstance;
        if (!queryConfig.HasPartitionKeyValue("pk"))
            queryConfig.AddPartitionKeyValue(
                InvoiceEntityKeys.ComposeInvoicePartitionKey(invoiceId));
        if (!queryConfig.HasRangeKeyValue("sk"))
            queryConfig.AddSortKeyValue(
                DbFunc.Equals(InvoiceEntityKeys.ComposeInvoiceSortKey()));

        return GetSingleAsync(
            queryConfig.ReturnEventualConsistentData(!isConsistentRead));
    }
}

public InvoiceRepository(MarketplaceDbContext dbContext)
    : base(dbContext)
{
    SetUnitOfWork(new UnitOfWork(dbContext));
}

public record struct InvoiceRepositoryItemCollection(
    InvoiceEntity? Invoice,
    InvoicePaymentEntity? InvoicePayment);

public enum InvoiceRepositoryItemCollectionType
{
    Invoice = 0,
    InvoicePayment = 1,
}

// On InvoiceRepository (getter body elided): created on first
// use, joined to the parent's unit of work.
public IInvoiceRepositoryInvoicePaymentEntityRepository
    InvoicePayment { get; }

public void BeginTransaction()
{
    UnitOfWork.BeginTransaction();
}

public Task CommitAsync(CancellationToken? cancellationToken = null)
{
    return UnitOfWork.TransactionExpressions.Count > 0
        ? UnitOfWork.CommitAsync(cancellationToken)
        : Task.CompletedTask;
}

// In the generated RegisterDynamoDbRepository() extension:
services.AddScoped<InvoiceRepository>();
services.AddScoped<IInvoiceRepository>(
    sp => sp.GetRequiredService<InvoiceRepository>());