feat: remove template bean

Signed-off-by: Otavio Santana <otaviopolianasantana@gmail.com>

jnosql-mapping/jnosql-mapping-document/src/main/java/org/eclipse/jnosql/mapping/document/DefaultDocumentTemplate.java

@@ -12,15 +12,15 @@
  *
  *   Otavio Santana
  */
-package org.eclipse.jnosql.mapping.column;
+package org.eclipse.jnosql.mapping.document;
 
 import jakarta.enterprise.context.ApplicationScoped;
 import jakarta.enterprise.inject.Default;
 import jakarta.inject.Inject;
 import org.eclipse.jnosql.communication.semistructured.DatabaseManager;
-import org.eclipse.jnosql.mapping.core.Converters;
 import org.eclipse.jnosql.mapping.Database;
 import org.eclipse.jnosql.mapping.DatabaseType;
+import org.eclipse.jnosql.mapping.core.Converters;
 import org.eclipse.jnosql.mapping.metadata.EntitiesMetadata;
 import org.eclipse.jnosql.mapping.semistructured.AbstractSemistructuredTemplate;
 import org.eclipse.jnosql.mapping.semistructured.EntityConverter;
@@ -29,7 +29,7 @@
 
 @Default
 @ApplicationScoped
-class DefaultColumnTemplate extends AbstractSemistructuredTemplate implements ColumnTemplate {
+class DefaultDocumentTemplate extends AbstractSemistructuredTemplate implements DocumentTemplate {
 
 
     private final EntityConverter converter;
@@ -45,18 +45,18 @@ class DefaultColumnTemplate extends AbstractSemistructuredTemplate implements Co
 
 
     @Inject
-    DefaultColumnTemplate(EntityConverter converter,
-                          @Database(DatabaseType.COLUMN) DatabaseManager manager,
-                          EventPersistManager eventManager,
-                          EntitiesMetadata entities, Converters converters){
+    DefaultDocumentTemplate(EntityConverter converter,
+                            @Database(DatabaseType.COLUMN) DatabaseManager manager,
+                            EventPersistManager eventManager,
+                            EntitiesMetadata entities, Converters converters){
         this.converter = converter;
         this.manager = manager;
         this.eventManager = eventManager;
         this.entities = entities;
         this.converters = converters;
     }
 
-    DefaultColumnTemplate() {
+    DefaultDocumentTemplate() {
         this(null, null, null, null, null);
     }
 

jnosql-mapping/jnosql-mapping-document/src/main/java/org/eclipse/jnosql/mapping/document/DocumentTemplate.java

@@ -1,6 +1,6 @@
 /*
  *
- *  Copyright (c) 2023 Contributors to the Eclipse Foundation
+ *  Copyright (c) 2024 Contributors to the Eclipse Foundation
  *   All rights reserved. This program and the accompanying materials
  *   are made available under the terms of the Eclipse Public License v1.0
  *   and Apache License v2.0 which accompanies this distribution.
@@ -14,7 +14,7 @@
  *   Otavio Santana
  *
  */
-package org.eclipse.jnosql.mapping.column;
+package org.eclipse.jnosql.mapping.document;
 
 
 
@@ -23,19 +23,19 @@
 
 /**
  * This interface extends the {@link SemistructuredTemplate} and represents a template for performing
- * column-based operations in a semistructured database.
+ * document-based operations in a semistructured database.
  * <p>
  * Implementations of this interface provide methods for CRUD (Create, Read, Update, Delete) operations
- * on column-based data structures within a semistructured database.
+ * on document-based data structures within a semistructured database.
  * </p>
  * <p>
- * Users can utilize implementations of this interface to interact with column-based data in a semistructured database,
+ * Users can utilize implementations of this interface to interact with document-based data in a semistructured database,
  * abstracting away the complexities of the underlying database operations and providing a unified API for database access.
  * </p>
  *
  * @see SemistructuredTemplate
  */
-public interface ColumnTemplate extends SemistructuredTemplate {
+public interface DocumentTemplate extends SemistructuredTemplate {
 
 
 }

jnosql-mapping/jnosql-mapping-document/src/main/java/org/eclipse/jnosql/mapping/document/DocumentTemplateProducer.java

@@ -14,96 +14,97 @@
  */
 package org.eclipse.jnosql.mapping.document;
 
-import org.eclipse.jnosql.communication.document.DocumentManager;
+import org.eclipse.jnosql.communication.semistructured.DatabaseManager;
 import org.eclipse.jnosql.mapping.core.Converters;
-import jakarta.nosql.document.DocumentTemplate;
 import org.eclipse.jnosql.mapping.metadata.EntitiesMetadata;
 
 import jakarta.enterprise.context.ApplicationScoped;
 import jakarta.enterprise.inject.Vetoed;
 import jakarta.inject.Inject;
+import org.eclipse.jnosql.mapping.semistructured.AbstractSemistructuredTemplate;
+import org.eclipse.jnosql.mapping.semistructured.EntityConverter;
+import org.eclipse.jnosql.mapping.semistructured.EventPersistManager;
 
 import java.util.Objects;
+import java.util.function.Function;
 
 /**
  * The producer of {@link DocumentTemplate}
  */
 @ApplicationScoped
-public class DocumentTemplateProducer {
+public class DocumentTemplateProducer implements Function<DatabaseManager, DocumentTemplate> {
 
     @Inject
-    private DocumentEntityConverter converter;
+    private EntityConverter converter;
 
     @Inject
-    private DocumentEventPersistManager persistManager;
+    private EventPersistManager eventManager;
 
     @Inject
     private EntitiesMetadata entities;
 
     @Inject
     private Converters converters;
 
-    /**
-     * creates a {@link DocumentManager}
-     *
-     * @param manager the manager
-     * @return a new instance
-     * @throws NullPointerException when manager is null
-     */
-    public JNoSQLDocumentTemplate get(DocumentManager manager) {
+
+    @Override
+    public DocumentTemplate apply(DatabaseManager manager) {
         Objects.requireNonNull(manager, "manager is required");
         return new ProducerDocumentTemplate(converter, manager,
-                persistManager, entities, converters);
+                eventManager, entities, converters);
     }
 
     @Vetoed
-    static class ProducerDocumentTemplate extends AbstractDocumentTemplate {
+    static class ProducerDocumentTemplate  extends AbstractSemistructuredTemplate implements DocumentTemplate {
 
-        private DocumentEntityConverter converter;
+        private final EntityConverter converter;
 
-        private DocumentManager manager;
+        private final  DatabaseManager manager;
 
-        private DocumentEventPersistManager persistManager;
+        private final EventPersistManager eventManager;
 
-        private Converters converters;
+        private final EntitiesMetadata entities;
 
-        private EntitiesMetadata entities;
+        private final  Converters converters;
 
-        ProducerDocumentTemplate(DocumentEntityConverter converter, DocumentManager manager,
-                                 DocumentEventPersistManager persistManager,
-                                 EntitiesMetadata entities, Converters converters) {
+        ProducerDocumentTemplate(EntityConverter converter,
+                               DatabaseManager manager,
+                               EventPersistManager eventManager,
+                               EntitiesMetadata entities,
+                               Converters converters) {
             this.converter = converter;
             this.manager = manager;
-            this.persistManager = persistManager;
+            this.eventManager = eventManager;
             this.entities = entities;
             this.converters = converters;
         }
 
         ProducerDocumentTemplate() {
+            this(null, null, null, null, null);
         }
 
         @Override
-        protected DocumentEntityConverter getConverter() {
+        protected EntityConverter converter() {
             return converter;
         }
 
         @Override
-        protected DocumentManager getManager() {
+        protected DatabaseManager manager() {
             return manager;
         }
 
         @Override
-        protected DocumentEventPersistManager getEventManager() {
-            return persistManager;
+        protected EventPersistManager eventManager() {
+            return eventManager;
         }
 
         @Override
-        protected EntitiesMetadata getEntities() {
+        protected EntitiesMetadata entities() {
             return entities;
         }
 
         @Override
-        protected Converters getConverters() {
+        protected Converters converters() {
             return converters;
         }
     }

jnosql-mapping/jnosql-mapping-document/src/main/java/org/eclipse/jnosql/mapping/document/configuration/DocumentManagerSupplier.java

@@ -16,9 +16,10 @@
 
 import jakarta.data.exceptions.MappingException;
 import org.eclipse.jnosql.communication.Settings;
-import org.eclipse.jnosql.communication.document.DocumentConfiguration;
-import org.eclipse.jnosql.communication.document.DocumentManager;
-import org.eclipse.jnosql.communication.document.DocumentManagerFactory;
+import org.eclipse.jnosql.communication.semistructured.DatabaseConfiguration;
+import org.eclipse.jnosql.communication.semistructured.DatabaseManager;
+import org.eclipse.jnosql.mapping.Database;
+import org.eclipse.jnosql.mapping.DatabaseType;
 import org.eclipse.jnosql.mapping.core.config.MicroProfileSettings;
 import org.eclipse.jnosql.mapping.reflection.Reflections;
 
@@ -35,36 +36,37 @@
 import static org.eclipse.jnosql.mapping.core.config.MappingConfigurations.DOCUMENT_PROVIDER;
 
 @ApplicationScoped
-class DocumentManagerSupplier implements Supplier<DocumentManager> {
+class DocumentManagerSupplier implements Supplier<DatabaseManager> {
 
     private static final Logger LOGGER = Logger.getLogger(DocumentManagerSupplier.class.getName());
 
     @Override
     @Produces
     @ApplicationScoped
-    public DocumentManager get() {
+    @Database(DatabaseType.DOCUMENT)
+    public DatabaseManager get() {
         Settings settings = MicroProfileSettings.INSTANCE;
 
-        DocumentConfiguration configuration = settings.get(DOCUMENT_PROVIDER, Class.class)
-                .filter(DocumentConfiguration.class::isAssignableFrom)
+        DatabaseConfiguration configuration = settings.get(DOCUMENT_PROVIDER, Class.class)
+                .filter(DatabaseConfiguration.class::isAssignableFrom)
                 .map(c -> {
                     final Reflections reflections = CDI.current().select(Reflections.class).get();
-                    return (DocumentConfiguration) reflections.newInstance(c);
-                }).orElseGet(DocumentConfiguration::getConfiguration);
+                    return (DatabaseConfiguration) reflections.newInstance(c);
+                }).orElseGet(DatabaseConfiguration::getConfiguration);
 
-        DocumentManagerFactory managerFactory = configuration.apply(settings);
+        var managerFactory = configuration.apply(settings);
 
         Optional<String> database = settings.get(DOCUMENT_DATABASE, String.class);
         String db = database.orElseThrow(() -> new MappingException("Please, inform the database filling up the property "
                 + DOCUMENT_DATABASE.get()));
-        DocumentManager manager = managerFactory.apply(db);
+        DatabaseManager manager = managerFactory.apply(db);
 
         LOGGER.log(Level.FINEST, "Starting  a DocumentManager instance using Eclipse MicroProfile Config," +
                 " database name: " + db);
         return manager;
     }
 
-    public void close(@Disposes DocumentManager manager) {
+    public void close(@Disposes @Database(DatabaseType.DOCUMENT) DatabaseManager manager) {
         LOGGER.log(Level.FINEST, "Closing DocumentManager resource, database name: " + manager.name());
         manager.close();
     }