Implement Discriminator-Based Multi-Tenancy with Claude Code

Managing data isolation for multiple tenants in a Spring Boot application, particularly when using a single database schema, presents a common development challenge. Discriminator-based multi-tenancy, where a tenant_id column segregates records, is a popular solution. While Spring Data JPA offers flexibility, manually crafting repository implementations for each entity to enforce this tenant_id filter becomes repetitive and prone to errors. This is precisely where Claude Code can streamline your workflow by generating essential boilerplate code.

Claude Code excels at producing the necessary code for a custom Spring Data JPA repository that automatically filters all CRUD operations based on the current tenant. By understanding Spring Data JPA interfaces and JPA entity structures, it can generate a TenantAwareRepository. This repository would extend JpaRepository and, crucially, apply a tenant_id filter to every query. The generated code often involves custom query methods or @Query annotations that dynamically inject a WHERE tenant_id = :currentTenantId clause, ensuring data is scoped correctly.

Consider the following instruction to Claude Code. The fundamental pattern involves defining a base repository interface that your entity-specific repositories will inherit, consolidating the multi-tenancy logic. For instance, instructing Claude to create a TenantAwareRepository for a Product entity with a tenantId field would result in code that correctly generates methods like findById, findAll, save, and delete, each implicitly filtered by the tenantId.

// Instruct Claude Code to generate this:
// Create a Spring Data JPA repository for the 'Product' entity.
// The Product entity has a field named 'tenantId' of type String.
// This repository should extend JpaRepository and filter all queries by the 'tenantId' field.
// Assume a mechanism exists to get the current tenant ID dynamically, e.g., using ThreadLocal.

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.repository.NoRepositoryBean;
import java.util.List;

@NoRepositoryBean
public interface TenantAwareRepository<T, ID> extends JpaRepository<T, ID> {

    // Claude will generate methods like these with tenant filtering
    // Example: findById, findAll, save, delete, etc.
    // For instance, a method to find all entities for the current tenant:
    @Override
    List<T> findAll();

    // A custom method that Claude can generate a query for:
    // @Query("SELECT e FROM #{#entityName} e WHERE e.tenantId = :currentTenantId")
    // List<T> findAllByCurrentTenant();
}

A significant “gotcha” in discriminator-based multi-tenancy is ensuring the accurate and secure propagation of the current tenant ID. This is typically managed using ThreadLocal or a request-scoped bean to maintain tenant context throughout a request. Improper context management can lead to data leaks or incorrect data retrieval. Furthermore, carefully plan for operations that must bypass tenant filtering, such as administrative tasks or bulk data imports, to avoid unintended data restrictions. Claude Code helps automate the implementation of the tenant filtering, but the strategy for context management and bypass scenarios remains a crucial architectural decision for senior developers.

Try it: Ask Claude Code to generate a TenantAwareRepository for a Spring Data JPA entity named Order with a tenantId field.