Jaunty ORM: Feature Gap Analysis & Roadmap

Last Updated: 2026-03-11 Status: Draft - For Discussion

Part 1: Completed Features (Production-Ready)

1.1 Core Query Operations

1.2 Write Operations (CRUD)

1.3 Parameter Handling

1.4 Caching (Internal)

1.5 Database Dialect Support

1.6 Attributes & Mapping

1.7 Configuration

1.8 Command Options

1.9 Multi-Entity Mapping

1.10 CSV Import

1.11 Logging and Diagnostics

1.12 Extensions (Separate Packages)

Part 2: Missing Features - Discussion Required

Priority P0: Critical for Production Adoption

2.1.1 Dependency Injection Integration

Status: Partially Complete - AddJauntyLogging() and ApplyJauntyInterceptors() extensions available

Problem: Limited DI integration. Manual interceptor registration required.

Proposed Solutions:

Decision Required:

• Support for multiple named connections?
• Connection factory abstraction or direct registration?
• Options pattern (IOptions<JauntyOptions>) or fluent config?
• Should connection pooling be managed?

Proposed API:

// Simple
services.AddJaunty<SqlConnection>("connection-string");

// Named connections
services.AddJaunty(options => {
    options.AddConnection<SqlConnection>("default", "conn1");
    options.AddConnection<SqlConnection>("analytics", "conn2");
});

// Factory-based
services.AddScoped<IDbConnectionFactory, MyConnectionFactory>();

2.1.2 Query Result Caching

Problem: No second-level cache. Every query hits the database.

Proposed Solutions:

Decision Required:

• Should caching be in core or extension?
• Cache invalidation strategy? (Time-based, write-through, manual)
• Per-query cache configuration?
• Cache key generation strategy?

Proposed API:

// Per-query caching
var products = connection.Query<Product>(
    sql,
    cache: CacheOptions.For("products:all", TimeSpan.FromMinutes(5)));

// Global configuration
services.AddJaunty(config => {
    config.UseCacheProvider(new RedisCacheProvider(...));
    config.DefaultCacheDuration = TimeSpan.FromMinutes(1);
});

Priority P1: High-Value Additions

2.2.1 Resilience & Retry Policies

Problem: No built-in retry for transient failures.

Proposed Solutions:

Decision Required:

• Use Polly or build simple retry?
• Which exceptions trigger retry? (Timeout, connection errors, deadlocks)
• Exponential backoff configuration?
• Circuit breaker pattern needed?

Proposed API:

// Simple retry
services.AddJaunty(config => {
    config.UseRetryPolicy(retry => {
        retry.MaxAttempts(3);
        retry.OnException<SqlException>();
        retry.ExponentialBackoff(TimeSpan.FromSeconds(1));
    });
});

// Polly integration
services.AddJaunty(config => {
    config.UsePollyPolicy(myResiliencePipeline);
});

2.2.2 Optimistic Concurrency

Problem: No automatic concurrency token handling.

Proposed Solutions:

Decision Required:

• Which concurrency strategy to support?
• Should Update() throw on concurrency violation?
• Return affected rows or throw exception?
• Support composite concurrency tokens?

Proposed API:

public class Product
{
    [Key]
    public int Id { get; set; }

    [RowVersion]  // SQL Server rowversion/timestamp
    public byte[] RowVersion { get; set; }

    // OR

    [ConcurrencyCheck]  // Compare original value
    public decimal Price { get; set; }
}

// Usage
try
{
    connection.Update(product);  // Throws DbConcurrencyException
}
catch (DbConcurrencyException ex)
{
    // Handle conflict
}

2.2.3 Soft Delete Support

Problem: No automatic soft delete filtering.

Proposed Solutions:

Decision Required:

• Automatic filtering or opt-in?
• Support for Delete<T>() conversion to soft delete?
• Include deleted entities option?
• Multiple deletion timestamp strategies?

Proposed API:

// Attribute approach
public class Product
{
    [SoftDelete(ColumnName = "DeletedAt")]
    public DateTime? DeletedAt { get; set; }
}

// Query automatically filters: WHERE DeletedAt IS NULL
connection.Query<Product>("SELECT * FROM Products");

// Include deleted
connection.Query<Product>("SELECT * FROM Products", includeSoftDeleted: true);

// Actual delete
connection.HardDelete(product);  // Actual DELETE
connection.Delete(product);      // Sets DeletedAt

Priority P2: Developer Experience

2.3.1 LINQ Provider

Problem: No LINQ support. Users must write raw SQL.

Decision Required:

• Is LINQ support aligned with Jaunty's philosophy?
• Full LINQ or limited subset?
• Translation to raw SQL or expression-based builder?

Note: This is a significant architectural decision. May warrant a separate ADR.

2.3.2 Change Tracking / Unit of Work

Problem: No identity map or change tracking.

Proposed Solutions:

Decision Required:

• Should Jaunty support change tracking at all?
• Scope of tracking (per-connection, per-unit-of-work)?
• Auto-detect changes or explicit marking?

2.3.3 Migration Framework

Problem: No code-first migrations.

Proposed Solutions:

Decision Required:

• Build migrations or integrate with existing tools?
• Support rollback/down migrations?
• Migration history tracking?

Priority P3: Nice-to-Have Features

2.4.1 Advanced Parameter Features

2.4.2 Audit & Compliance

2.4.3 Special Type Support

Part 3: Decision Log

Use this section to record decisions made during discussion.

Part 4: Implementation Roadmap (Post-Decision)

Phase 1: Foundation (P0 Items)

• ILogger Integration
• DI Integration
• Command Interception

Phase 2: Reliability (P1 Items)

• Resilience/Retry Policies
• Query Result Caching
• Optimistic Concurrency

Phase 3: Developer Experience (P2 Items)

• Soft Delete Support
• Migration Framework (decision pending)

Phase 4: Advanced Features (P3 Items)

• Table-Valued Parameters
• JSON Type Mapping
• Audit Features

Appendix A: Related Documentation

• ARCHITECTURE-DECISIONS.md
• Design Philosophy
• Known Limitations