Fudie.Generator 1.0.12

Fudie.Generator

Source Generator for automatic repository implementations with Entity Framework Core.

Table of Contents

• Base Interfaces
• Attributes
• Query Method Conventions
  • Query Prefixes
  • Operators
  • Modifiers
  • Full Examples
• Tracking

Base Interfaces

The generator recognizes the following infrastructure interfaces:

Basic Example

public interface ICustomerRepository : IGet<Customer, Guid>, IAdd<Customer>
{
}
// Generates: Get(Guid id) and Add(Customer entity)

Attributes

[GenerateRepository<TEntity>] / [GenerateRepository<TEntity, TId>]

Allows creating query-only repositories without exposing unsafe Get(id) methods.

[GenerateRepository<Ingredient>]
public interface IIngredientQueries
{
    Task<List<Ingredient>> FindByRestaurantId(Guid restaurantId);
}

[Include<TEntity>("path", ...)]

Configures eager loading with Include/ThenInclude.

[Include<Customer>("Orders.OrderItems.Product", "Address")]
public interface ICustomerRepository : IGet<Customer, Guid> { }

Generated LINQ:

query = query.Include(c => c.Orders)
    .ThenInclude(o => o.OrderItems)
    .ThenInclude(oi => oi.Product);
query = query.Include(c => c.Address);

[Tracking] / [Tracking(bool)]

Enables change tracking. Applicable to interfaces and methods.

[AsNoTracking]

Disables change tracking. Applicable to interfaces and methods.

[AsSplitQuery]

Uses split queries to avoid cartesian explosion.

[IgnoreQueryFilters]

Ignores global query filters (e.g. soft delete).

Query Method Conventions

The generator parses method names and generates LINQ code automatically.

Query Prefixes

Operators

Modifiers

Logical Connectors

Case Insensitive

Ordering

Full Examples

1. Simple Search

Task<List<Customer>> FindByName(string name);

LINQ:

return await _query.Query<Customer>()
    .Where(x => x.Name == name)
    .ToListAsync();

2. First Result with Two Conditions

Task<Customer?> FindFirstByIdAndRestaurantId(Guid id, Guid restaurantId);

LINQ:

return await _query.Query<Customer>()
    .Where(x => x.Id == id && x.RestaurantId == restaurantId)
    .FirstOrDefaultAsync();

3. Search with OR

Task<List<User>> FindByEmailOrPhone(string email, string phone);

LINQ:

return await _query.Query<User>()
    .Where(x => x.Email == email || x.Phone == phone)
    .ToListAsync();

4. Value Range

Task<List<Product>> FindByPriceBetween(decimal min, decimal max);

LINQ:

return await _query.Query<Product>()
    .Where(x => x.Price >= min && x.Price <= max)
    .ToListAsync();

5. Values in List

Task<List<Order>> FindByStatusIn(List<OrderStatus> statuses);

LINQ:

return await _query.Query<Order>()
    .Where(x => statuses.Contains(x.Status))
    .ToListAsync();

6. Case Insensitive

Task<List<Customer>> FindByNameIgnoreCase(string name);

LINQ:

return await _query.Query<Customer>()
    .Where(x => x.Name.ToLower() == name.ToLower())
    .ToListAsync();

7. With Ordering

Task<List<Product>> FindByCategoryOrderByPriceDesc(string category);

LINQ:

return await _query.Query<Product>()
    .Where(x => x.Category == category)
    .OrderByDescending(x => x.Price)
    .ToListAsync();

8. Top N Results

Task<List<Product>> FindTop5ByIsActiveTrue();

LINQ:

return await _query.Query<Product>()
    .Where(x => x.IsActive == true)
    .Take(5)
    .ToListAsync();

9. Count with Condition

Task<int> CountByRestaurantIdAndIsActiveTrue(Guid restaurantId);

LINQ:

return await _query.Query<Ingredient>()
    .Where(x => x.RestaurantId == restaurantId && x.IsActive == true)
    .CountAsync();

10. Check Existence

Task<bool> ExistsByEmailIgnoreCase(string email);

LINQ:

return await _query.Query<User>()
    .Where(x => x.Email.ToLower() == email.ToLower())
    .AnyAsync();

11. Bulk Delete

Task<int> DeleteByIsDeletedTrueAndDeletedAtLessThan(DateTime cutoff);

LINQ:

return await _query.Query<AuditLog>()
    .Where(x => x.IsDeleted == true && x.DeletedAt < cutoff)
    .ExecuteDeleteAsync();

12. String Operations

Task<List<Customer>> FindByNameStartsWithAndEmailEndsWith(string prefix, string domain);

LINQ:

return await _query.Query<Customer>()
    .Where(x => x.Name.StartsWith(prefix) && x.Email.EndsWith(domain))
    .ToListAsync();

13. Null Checks

Task<List<Employee>> FindByManagerIsNullAndDepartmentIsNotNull();

LINQ:

return await _query.Query<Employee>()
    .Where(x => x.Manager == null && x.Department != null)
    .ToListAsync();

Tracking

Tracking can be configured at the interface or method level. Method-level attributes take priority.

Priority Rules

1. Method attribute → Always wins
2. Interface attribute → Default for methods without attribute
3. No attributes → Default is AsNoTracking (no tracking)

Generated Dependencies

Example: Mixed Tracking

[GenerateRepository<Ingredient>]
public interface IIngredientRepository
{
    // No tracking - read only
    [AsNoTracking]
    Task<List<Ingredient>> FindByName(string name);

    // With tracking - for later modification
    [Tracking]
    Task<Ingredient?> FindFirstByIdAndRestaurantId(Guid id, Guid restaurantId);
}

Generated Code:

public class IngredientRepository : IIngredientRepository
{
    private readonly IEntityLookup _entityLookup;  // For tracked methods
    private readonly IQuery _query;                 // For untracked methods

    public IngredientRepository(IEntityLookup entityLookup, IQuery query)
    {
        _entityLookup = entityLookup;
        _query = query;
    }

    public async Task<List<Ingredient>> FindByName(string name)
    {
        return await _query.Query<Ingredient>()  // No tracking
            .Where(x => x.Name == name)
            .ToListAsync();
    }

    public async Task<Ingredient?> FindFirstByIdAndRestaurantId(Guid id, Guid restaurantId)
    {
        return await _entityLookup.Set<Ingredient>()  // With tracking
            .Where(x => x.Id == id && x.RestaurantId == restaurantId)
            .FirstOrDefaultAsync();
    }
}

Example: Interface-Level Tracking

[GenerateRepository<Ingredient>]
[AsNoTracking]  // Default for all methods
public interface IIngredientReadRepository
{
    Task<List<Ingredient>> FindByRestaurantId(Guid restaurantId);

    [Tracking]  // Override: this method DOES use tracking
    Task<Ingredient?> FindFirstByIdAndRestaurantId(Guid id, Guid restaurantId);
}

Multi-Tenant Use Cases

For security in multi-tenant applications, use [GenerateRepository] instead of IGet:

// BAD - Get(id) does not filter by tenant
public interface IIngredientRepository : IGet<Ingredient, Guid> { }

// GOOD - Only exposes methods that require tenant
[GenerateRepository<Ingredient>]
public interface IIngredientRepository
{
    Task<Ingredient?> FindFirstByIdAndRestaurantId(Guid id, Guid restaurantId);
    Task<List<Ingredient>> FindByRestaurantId(Guid restaurantId);
}

Summary: Method → LINQ