Everything inside the without block is already provided by BaseRepository — you don't need to write it.

@Repository
public class ArticleRepository {

    public Article findById(int id) {
        return Model.find(Article.class, id);  // already in BaseRepository
    }

    public List<Article> findAll() {
        return Model.all(Article.class);       // already in BaseRepository
    }

    public boolean save(Article article) {
        return article.save();                 // already in BaseRepository
    }

    public boolean delete(int id) {
        Article a = Model.find(Article.class, id);
        if (a == null) return false;
        return a.delete();                     // already in BaseRepository
    }
}

@Repository
public class ArticleRepository extends BaseRepository<Article> {

    public ArticleRepository() {
        super(Article.class);
    }

    // findById, findAll, save, delete, count, paginate... all inherited

    // Only add what's specific to articles:
    public List<Article> findPublished() {
        return query().where("status", 1).orderByDesc("created_at").get();
    }

    public Optional<Article> findBySlug(String slug) {
        return Optional.ofNullable(findBy("slug", slug));
    }
}

Use query() to start a builder scoped to your model for anything that goes beyond the built-ins:

@Repository
public class ArticleRepository extends BaseRepository<Article> {

    public ArticleRepository() { super(Article.class); }

    public Paginator<Article> paginatePublished(int page) {
        return query()
                .where("status", 1)
                .orderByDesc("created_at")
                .paginate(page, 15);
    }

    public List<Article> findByAuthorWithComments(int userId) {
        return query()
                .where("user_id", userId)
                .with("comments", "author")
                .get();
    }

    public List<Article> findRecentByCategory(int categoryId, int limit) {
        return query()
                .where("category_id", categoryId)
                .where("status", 1)
                .orderByDesc("created_at")
                .limit(limit)
                .get();
    }
}

Find the first record matching search and update it with attributes, or create a new one merging both if none is found.

// Updates Alice's role if found, creates her if not
User user = userRepo.updateOrCreate(
    Map.of("email", "alice@example.com"),
    Map.of("role", "admin", "active", 1)
);

Process large tables without loading everything into memory. The callback receives one batch at a time.

// Process all users 500 at a time
userRepo.chunk(500, users -> {
    users.forEach(u -> u.set("active", 1).save());
});

// Same with a WHERE filter
userRepo.chunkWhere("role", "user", 200, users -> {
    users.forEach(u -> notificationService.send(u));
});

Uses offset-based pagination internally. Avoid inserting or deleting rows in the same table during iteration — pages may shift.

Insert multiple rows, updating on conflict. Uses dialect-specific syntax — ON DUPLICATE KEY UPDATE on MySQL, ON CONFLICT DO UPDATE on PostgreSQL and SQLite.

List<Map<String, Object>> rows = List.of(
    Map.of("email", "alice@example.com", "name", "Alice", "role", "admin"),
    Map.of("email", "bob@example.com",   "name", "Bob",   "role", "user")
);

// Conflict on email — updates all non-unique columns on conflict
userRepo.upsert(rows, List.of("email"));

// Only update the role column on conflict
userRepo.upsert(rows, List.of("email"), List.of("role"));

The uniqueKeys column must have a UNIQUE or PRIMARY KEY constraint in the database schema. SQLite requires version 3.24+.

@Controller("/articles")
public class ArticleController extends BaseController {

    @GET("")
    private Object index(ArticleRepository articles, Request req) {
        int page = Integer.parseInt(req.queryParamOrDefault("page", "1"));
        return render("articles/index.html", Map.of(
            "articles", articles.paginatePublished(page)
        ));
    }

    @GET("/:id")
    private Object show(ArticleRepository articles, Request req) {
        Article article = articles.findByIdOrFail(req.params("id"));
        return render("articles/show.html", Map.of("article", article));
    }
}