@Entity
public class Movie {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String director;
    private String title;
    private int year;

    @Enumerated(EnumType.STRING)
    private Genre genre;

    public Movie() {
    }

    public Movie(final String director, final String title, final int year, final Genre genre) {
        this.director = director;
        this.title = title;
        this.year = year;
        this.genre = genre;
    }

    // getters and setters ...
}

@Stateless
public class MovieDao {

    @PersistenceContext(unitName = "movie-unit")
    private EntityManager em;

    public void addMovie(final Movie movie) {
        em.persist(movie);
    }

    public List<Movie> findAll() {
        return em.createQuery("SELECT m FROM Movie m ORDER BY m.title", Movie.class)
            .getResultList();
    }

    public List<Movie> findByDirectorAndGenre(final String director, final Genre genre) {
        final CriteriaBuilder cb = em.getCriteriaBuilder();
        final CriteriaQuery<Movie> cq = cb.createQuery(Movie.class);
        final Root<Movie> root = cq.from(Movie.class);

        cq.where(
            cb.and(
                cb.equal(root.get("director"), director),
                cb.equal(root.get("genre"), genre)
            )
        );
        cq.orderBy(cb.asc(root.get("year")));

        return em.createQuery(cq).getResultList();
    }

    // more methods ...
}

@Repository
public interface MovieRepository extends CrudRepository<Movie, Long> {

    List<Movie> findByDirector(String director);

    List<Movie> findByGenre(Genre genre);

    @OrderBy("year")
    List<Movie> findByYearGreaterThanEqual(int year);

    @Query("SELECT m FROM Movie m WHERE m.genre = ?1 AND m.year BETWEEN ?2 AND ?3 ORDER BY m.title")
    List<Movie> findByGenreAndYearRange(Genre genre, int startYear, int endYear);

    long countByGenre(Genre genre);

    long countByDirector(String director);
}

@ApplicationScoped
public class MovieService {

    @EJB
    private MovieDao movieDao;

    @Inject
    private MovieRepository movieRepository;

    // Classic JPA
    public void addMovieClassic(final String director, final String title, final int year, final Genre genre) {
        movieDao.addMovie(new Movie(director, title, year, genre));
    }

    // Jakarta Data
    public Movie addMovieData(final String director, final String title, final int year, final Genre genre) {
        return movieRepository.insert(new Movie(director, title, year, genre));
    }

    // Query via Jakarta Data, even for JPA-inserted data
    public long countByDirectorViaRepository(final String director) {
        return movieRepository.countByDirector(director);
    }

    // Query via classic JPA, even for Jakarta Data-inserted data
    public List<Movie> findByGenreViaDao(final Genre genre) {
        return movieDao.findByGenre(genre);
    }
}

@Test
public void testJpaInsertVisibleViaDataRepository() throws Exception {
    utx.begin();
    try {
        // Insert using classic JPA EntityManager
        movieDao.addMovie(new Movie("Ridley Scott", "Blade Runner", 1982, Genre.SCI_FI));
        movieDao.addMovie(new Movie("Ridley Scott", "Alien", 1979, Genre.SCI_FI));

        // Query using Jakarta Data repository -- sees JPA-persisted data
        final List<Movie> sciFi = movieRepository.findByGenre(Genre.SCI_FI);
        assertEquals(2, sciFi.size());
    } finally {
        utx.rollback();
    }
}

@Test
public void testMixedInsertAndQuery() throws Exception {
    utx.begin();
    try {
        // Insert some via JPA, some via Jakarta Data
        movieDao.addMovie(new Movie("Denis Villeneuve", "Arrival", 2016, Genre.SCI_FI));
        movieRepository.insert(new Movie("Denis Villeneuve", "Dune", 2021, Genre.SCI_FI));

        // Both approaches see all data
        assertEquals(2, movieDao.count());
        assertEquals(2, movieRepository.countByDirector("Denis Villeneuve"));
    } finally {
        utx.rollback();
    }
}

<persistence version="3.0"
             xmlns="https://jakarta.ee/xml/ns/persistence">
  <persistence-unit name="movie-unit">
    <jta-data-source>movieDatabase</jta-data-source>
    <non-jta-data-source>movieDatabaseUnmanaged</non-jta-data-source>
    <class>org.superbiz.combined.Movie</class>
    <properties>
      <property name="openjpa.jdbc.SynchronizeMappings" value="buildSchema(ForeignKeys=true)"/>
    </properties>
  </persistence-unit>
</persistence>