feat: update hazelcast api to key-value repository

Signed-off-by: Otavio Santana <[email protected]>

Author: otaviojava

jnosql-hazelcast/src/main/java/org/eclipse/jnosql/databases/hazelcast/mapping/HazelcastRepositoryBean.java

@@ -14,12 +14,11 @@
  */
 package org.eclipse.jnosql.databases.hazelcast.mapping;
 
-import jakarta.data.repository.PageableRepository;
 import jakarta.enterprise.context.spi.CreationalContext;
 import jakarta.enterprise.inject.Default;
 import jakarta.enterprise.util.AnnotationLiteral;
-import org.eclipse.jnosql.mapping.keyvalue.query.KeyValueRepositoryProducer;
 import org.eclipse.jnosql.mapping.core.spi.AbstractBean;
+import org.eclipse.jnosql.mapping.metadata.EntitiesMetadata;
 
 import java.lang.annotation.Annotation;
 import java.lang.reflect.Proxy;
@@ -28,16 +27,16 @@
 import java.util.Set;
 
 
-class HazelcastRepositoryBean extends AbstractBean<HazelcastRepository> {
+class HazelcastRepositoryBean<T, K> extends AbstractBean<HazelcastRepository<T, K>> {
 
-    private final Class type;
+    private final Class<T> type;
 
     private final Set<Type> types;
 
     private final Set<Annotation> qualifiers = Collections.singleton(new AnnotationLiteral<Default>() {
     });
 
-    HazelcastRepositoryBean(Class type) {
+    HazelcastRepositoryBean(Class<T> type) {
         this.type = type;
         this.types = Collections.singleton(type);
     }
@@ -48,13 +47,13 @@ public Class<?> getBeanClass() {
     }
 
 
+    @SuppressWarnings("rawtypes")
     @Override
-    public HazelcastRepository create(CreationalContext<HazelcastRepository> creationalContext) {
+    public HazelcastRepository<T, K> create(CreationalContext<HazelcastRepository<T, K>> creationalContext) {
         HazelcastTemplate template = getInstance(HazelcastTemplate.class);
+        EntitiesMetadata entitiesMetadata = getInstance(EntitiesMetadata.class);
 
-        KeyValueRepositoryProducer producer = getInstance(KeyValueRepositoryProducer.class);
-        PageableRepository<?, ?> repository = producer.get((Class<PageableRepository<Object, Object>>) type, template);
-        HazelcastRepositoryProxy handler = new HazelcastRepositoryProxy(template, type, repository);
+        HazelcastRepositoryProxy<T, K> handler = new HazelcastRepositoryProxy<>(template, type, entitiesMetadata);
         return (HazelcastRepository) Proxy.newProxyInstance(type.getClassLoader(),
                 new Class[]{type},
                 handler);

jnosql-hazelcast/src/main/java/org/eclipse/jnosql/databases/hazelcast/mapping/HazelcastRepositoryProxy.java

@@ -14,10 +14,13 @@
  */
 package org.eclipse.jnosql.databases.hazelcast.mapping;
 
-import jakarta.data.repository.PageableRepository;
 import jakarta.nosql.keyvalue.KeyValueTemplate;
+import org.eclipse.jnosql.mapping.core.query.AbstractRepository;
 import org.eclipse.jnosql.mapping.keyvalue.query.AbstractKeyValueRepositoryProxy;
 import org.eclipse.jnosql.mapping.core.repository.DynamicReturn;
+import org.eclipse.jnosql.mapping.keyvalue.query.DefaultKeyValueRepository;
+import org.eclipse.jnosql.mapping.metadata.EntitiesMetadata;
+import org.eclipse.jnosql.mapping.metadata.EntityMetadata;
 
 import java.lang.reflect.Method;
 import java.lang.reflect.ParameterizedType;
@@ -31,33 +34,37 @@ class HazelcastRepositoryProxy<T, K> extends AbstractKeyValueRepositoryProxy<T,
 
     private final HazelcastTemplate template;
 
-    private final PageableRepository<?, ?> repository;
+    private final AbstractRepository<T, K> repository;
 
     private final Class<T> typeClass;
 
     private final Class<?> repositoryType;
 
+    private final EntityMetadata metadata;
 
-    HazelcastRepositoryProxy(HazelcastTemplate template, Class<?> repositoryType, PageableRepository<?, ?> repository) {
+
+
+    HazelcastRepositoryProxy(HazelcastTemplate template, Class<?> repositoryType, EntitiesMetadata entitiesMetadata) {
         this.template = template;
         this.typeClass = Class.class.cast(ParameterizedType.class.cast(repositoryType.getGenericInterfaces()[0])
                 .getActualTypeArguments()[0]);
-        this.repository = repository;
+        this.metadata = entitiesMetadata.get(typeClass);
+        this.repository = DefaultKeyValueRepository.of(template, metadata);
         this.repositoryType = repositoryType;
     }
 
     @Override
-    protected PageableRepository getRepository() {
+    protected AbstractRepository<T, K> repository() {
         return repository;
     }
 
     @Override
-    protected KeyValueTemplate getTemplate() {
+    protected KeyValueTemplate template() {
         return template;
     }
 
     @Override
-    protected Class<T> getType() {
+    protected Class<T> type() {
         return typeClass;
     }
 
@@ -66,6 +73,11 @@ protected Class<?> repositoryType() {
         return repositoryType;
     }
 
+    @Override
+    protected EntityMetadata entityMetadata() {
+        return metadata;
+    }
+
     @Override
     public Object invoke(Object instance, Method method, Object[] args) throws Throwable {
 

jnosql-hazelcast/src/test/java/org/eclipse/jnosql/databases/hazelcast/mapping/HazelcastRepositoryProxyTest.java

@@ -14,10 +14,11 @@
  */
 package org.eclipse.jnosql.databases.hazelcast.mapping;
 
-import jakarta.data.repository.PageableRepository;
+import jakarta.inject.Inject;
 import org.eclipse.jnosql.mapping.core.Converters;
 import org.eclipse.jnosql.mapping.keyvalue.AbstractKeyValueTemplate;
 import org.eclipse.jnosql.mapping.keyvalue.spi.KeyValueExtension;
+import org.eclipse.jnosql.mapping.metadata.EntitiesMetadata;
 import org.eclipse.jnosql.mapping.reflection.Reflections;
 import org.eclipse.jnosql.mapping.core.spi.EntityMetadataExtension;
 import org.jboss.weld.junit5.auto.AddExtensions;
@@ -60,8 +61,10 @@ public class HazelcastRepositoryProxyTest {
     @Mock
     private HazelcastTemplate template;
 
-    @Mock
-    private PageableRepository<?, ?> repository;
+
+    @Inject
+    private EntitiesMetadata entitiesMetadata;
+
     private PersonRepository personRepository;
 
 
@@ -72,7 +75,7 @@ public void setUp() {
         Collection<Object> people = asList(new Person("Poliana", 25), new Person("Otavio", 28));
 
         when(template.sql(anyString())).thenReturn(people);
-        HazelcastRepositoryProxy handler = new HazelcastRepositoryProxy<>(template, PersonRepository.class, repository);
+        HazelcastRepositoryProxy handler = new HazelcastRepositoryProxy<>(template, PersonRepository.class, entitiesMetadata);
 
         when(template.sql(anyString(), any(Map.class))).thenReturn(people);