Feature/554 fix mongo

api-rest/src/main/java/com/homihq/db2rest/jdbc/config/JdbcConfiguration.java

@@ -5,7 +5,7 @@
 import com.homihq.db2rest.jdbc.JdbcManager;
 import com.homihq.db2rest.jdbc.config.dialect.*;
 
-import com.homihq.db2rest.jdbc.multidb.DatabaseProperties;
+import com.homihq.db2rest.multidb.DatabaseProperties;
 import com.homihq.db2rest.jdbc.multidb.RoutingDataSource;
 import com.homihq.db2rest.jdbc.tsid.TSIDProcessor;
 import com.homihq.db2rest.jdbc.core.DbOperationService;
@@ -35,7 +35,6 @@
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.DependsOn;
-import org.springframework.jdbc.core.JdbcTemplate;
 import org.thymeleaf.spring6.SpringTemplateEngine;
 
 import javax.sql.DataSource;
@@ -52,9 +51,12 @@ public class JdbcConfiguration {
 
     private final DatabaseProperties databaseProperties;
     private final ObjectMapper objectMapper;
+
+
     @Bean
     @ConditionalOnMissingBean(DataSource.class)
     public DataSource dataSource() {
+
         final Map<Object, Object> dataSources = this.buildDataSources();
 
         final RoutingDataSource routingDataSource = new RoutingDataSource();
@@ -69,7 +71,6 @@ private Map<Object, Object> buildDataSources() {
 
         for (Map<String,String> db : databaseProperties.getDatabases()) {
             result.put(db.get("name"), this.buildDataSource(db));
-            log.info("db - {}", db);
         }
 
         return result;
@@ -97,7 +98,7 @@ public JdbcManager jdbcManager() {
                 ,new OracleDialect(objectMapper)
         );
 
-        return new JdbcManager(dataSource(), databaseProperties, dialects);
+        return new JdbcManager(dataSource(), dialects);
     }
 
     @Bean

api-rest/src/main/java/com/homihq/db2rest/jdbc/config/WebMvcConfiguration.java

@@ -2,19 +2,22 @@
 
 import com.homihq.db2rest.jdbc.rest.interceptor.DatabaseContextRequestInterceptor;
 import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
 import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
 
 @Configuration
 @RequiredArgsConstructor
+@Slf4j
 public class WebMvcConfiguration implements WebMvcConfigurer {
 
 
     private final DatabaseContextRequestInterceptor databaseContextRequestInterceptor;
 
     @Override
     public void addInterceptors(InterceptorRegistry registry) {
+        log.info("==== Registering DatabaseContextRequestInterceptor ====");
         registry.addInterceptor(databaseContextRequestInterceptor);
     }
 }

api-rest/src/main/java/com/homihq/db2rest/jdbc/rest/interceptor/DatabaseContextRequestInterceptor.java

@@ -1,7 +1,7 @@
 package com.homihq.db2rest.jdbc.rest.interceptor;
 
 import com.homihq.db2rest.core.exception.GenericDataAccessException;
-import com.homihq.db2rest.jdbc.multidb.DatabaseContextHolder;
+import com.homihq.db2rest.multidb.DatabaseContextHolder;
 import jakarta.servlet.http.HttpServletRequest;
 import jakarta.servlet.http.HttpServletResponse;
 import lombok.extern.slf4j.Slf4j;

api-rest/src/main/java/com/homihq/db2rest/mongo/config/MongoConfiguration.java

@@ -1,36 +1,62 @@
 package com.homihq.db2rest.mongo.config;
 
 import com.homihq.db2rest.config.Db2RestConfigProperties;
-
 import com.homihq.db2rest.mongo.rest.MongoController;
-
+import com.homihq.db2rest.multidb.DatabaseProperties;
+import com.homihq.db2test.mongo.multidb.RoutingMongoTemplate;
 import com.homihq.db2test.mongo.repository.MongoRepository;
 import com.homihq.db2test.mongo.rsql.RsqlMongodbAdapter;
 import com.homihq.db2test.mongo.rsql.argconverters.NoOpConverter;
 import com.homihq.db2test.mongo.rsql.argconverters.StringToQueryValueConverter;
 import com.homihq.db2test.mongo.rsql.visitor.ComparisonToCriteriaConverter;
 import com.mongodb.client.MongoClients;
-import org.springframework.beans.factory.annotation.Value;
+import lombok.RequiredArgsConstructor;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.DependsOn;
 import org.springframework.data.mongodb.core.MongoTemplate;
 import org.springframework.data.mongodb.core.SimpleMongoClientDatabaseFactory;
 
-import java.util.List;
+import java.util.*;
 
 @Configuration
 @ConditionalOnProperty(prefix = "db2rest.datasource", name = "type", havingValue = "mongo")
+@RequiredArgsConstructor
 public class MongoConfiguration {
 
-    @Value("${spring.data.mongodb.uri}")
-    String mongoUri;
-    @Value("${spring.data.mongodb.database}")
-    String databaseName;
+
+    private final DatabaseProperties databaseProperties;
 
     @Bean
-    public MongoTemplate mongoTemplate() {
+    @ConditionalOnMissingBean(RoutingMongoTemplate.class)
+    public RoutingMongoTemplate routingMongoTemplate() {
+
+        System.out.println("databaseProperties - " +  databaseProperties.getDatabases());
+
+        List<Map<String, String>> mongoDbs =
+        databaseProperties.getDatabases()
+                .stream()
+                .filter(m -> StringUtils.equalsIgnoreCase(m.get("type"), "mongo"))
+                .toList();
+
+        RoutingMongoTemplate routingMongoTemplate = new RoutingMongoTemplate();
+        if(!mongoDbs.isEmpty()) {
+
+            for(Map<String,String> mongo : mongoDbs){
+
+                routingMongoTemplate.add(mongo.get("name"), mongoTemplate(mongo.get("url"), mongo.get("database")));
+            }
+
+        }
+
+        return routingMongoTemplate;
+    }
+
+
+    private MongoTemplate mongoTemplate(String mongoUri, String databaseName) {
         SimpleMongoClientDatabaseFactory simpleMongoClientDatabaseFactory =
                 new SimpleMongoClientDatabaseFactory(
                         MongoClients.create(mongoUri), databaseName
@@ -40,13 +66,13 @@ public MongoTemplate mongoTemplate() {
     }
 
 
-    @DependsOn("mongoTemplate")
+    @DependsOn("routingMongoTemplate")
     public MongoRepository mongoRepository() {
-        return new MongoRepository(mongoTemplate());
+        return new MongoRepository(routingMongoTemplate());
     }
 
     @Bean
-    @DependsOn("mongoTemplate")
+    @DependsOn("routingMongoTemplate")
     public MongoController mongoController(Db2RestConfigProperties db2RestConfigProperties) {
         return new MongoController(mongoRepository(), rsqlMongoAdapter(List.of(noOpConverter())),
                 db2RestConfigProperties);

api-rest/src/main/java/com/homihq/db2rest/mongo/rest/api/MongoRestApi.java

@@ -21,30 +21,30 @@
 
 public interface MongoRestApi {
     @ResponseStatus(HttpStatus.CREATED)
-    @PostMapping("/{collectionName}")
+    @PostMapping("/{dbName}/{collectionName}")
     CreateResponse save(@PathVariable String collectionName,
                         @RequestParam(name = "fields", required = false) List<String> includeFields,
                         @RequestBody Map<String, Object> data);
 
     @ResponseStatus(HttpStatus.CREATED)
-    @PostMapping("/{collectionName}/bulk")
+    @PostMapping("/{dbName}/{collectionName}/bulk")
     CreateBulkResponse saveAll(@PathVariable String collectionName,
                                @RequestParam(name = "fields", required = false) List<String> includeFields,
                                @RequestBody List<Map<String, Object>> dataList);
 
     @ResponseStatus(HttpStatus.OK)
-    @PatchMapping("/{collectionName}")
+    @PatchMapping("/{dbName}/{collectionName}")
     UpdateResponse patch(@PathVariable String collectionName,
                          @RequestBody Map<String, Object> data,
                          @RequestParam(name = "filter", required = false, defaultValue = "") String filter);
 
     @ResponseStatus(HttpStatus.OK)
-    @DeleteMapping("/{collectionName}")
+    @DeleteMapping("/{dbName}/{collectionName}")
     DeleteResponse delete(@PathVariable String collectionName,
                           @RequestParam(name = "filter", required = false, defaultValue = "") String filter);
 
     @ResponseStatus(HttpStatus.OK)
-    @GetMapping("/{collectionName}")
+    @GetMapping("/{dbName}/{collectionName}")
     Object findAll(@PathVariable String collectionName,
                    @RequestParam(name = "fields", required = false, defaultValue = "*") String fields,
                    @RequestParam(name = "filter", required = false, defaultValue = "") String filter,
@@ -53,18 +53,18 @@ Object findAll(@PathVariable String collectionName,
                    @RequestParam(name = "offset", required = false, defaultValue = "-1") long offset);
 
     @ResponseStatus(HttpStatus.OK)
-    @GetMapping("/{collectionName}/one")
+    @GetMapping("/{dbName}/{collectionName}/one")
     Map<String, Object> findOne(@PathVariable String collectionName,
                                 @RequestParam(name = "fields", required = false, defaultValue = "*") String fields,
                                 @RequestParam(name = "filter", required = false, defaultValue = "") String filter);
 
     @ResponseStatus(HttpStatus.OK)
-    @GetMapping("/{collectionName}/count")
+    @GetMapping("/{dbName}/{collectionName}/count")
     CountResponse count(@PathVariable String collectionName,
                         @RequestParam(name = "filter", required = false, defaultValue = "") String filter);
 
     @ResponseStatus(HttpStatus.OK)
-    @GetMapping(value = "/{collectionName}/exists")
+    @GetMapping(value = "/{dbName}/{collectionName}/exists")
     ExistsResponse exists(@PathVariable String collectionName,
                           @RequestParam(name = "filter", defaultValue = "") String filter);
 }

api-rest/src/main/resources/application-local.yml

@@ -1,4 +1,3 @@
-#DB1
 app:
   databases:
     - name: DB1

api-rest/src/test/java/com/homihq/db2rest/MongoBaseIntegrationTest.java

@@ -0,0 +1,12 @@
+package com.homihq.db2rest;
+
+
+import org.springframework.context.annotation.Import;
+import org.springframework.test.context.ActiveProfiles;
+
+@Import(MongoContainerConfiguration.class)
+@ActiveProfiles("it-mongo")
+public class MongoBaseIntegrationTest extends BaseIntegrationTest{
+
+
+}

api-rest/src/test/java/com/homihq/db2rest/MongodbContainerConfiguration.java → api-rest/src/test/java/com/homihq/db2rest/MongoContainerConfiguration.java

@@ -1,10 +1,12 @@
 package com.homihq.db2rest;
 
+import com.homihq.db2test.mongo.multidb.RoutingMongoTemplate;
+import com.mongodb.client.MongoClients;
 import org.junit.jupiter.api.extension.ExtendWith;
-import org.springframework.context.annotation.Profile;
+import org.springframework.context.annotation.Bean;
+import org.springframework.data.mongodb.core.MongoTemplate;
+import org.springframework.data.mongodb.core.SimpleMongoClientDatabaseFactory;
 import org.springframework.restdocs.RestDocumentationExtension;
-import org.springframework.test.context.DynamicPropertyRegistry;
-import org.springframework.test.context.DynamicPropertySource;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
@@ -13,7 +15,7 @@
 
 @Testcontainers
 @ExtendWith({RestDocumentationExtension.class})
-public class MongodbContainerConfiguration {
+public class MongoContainerConfiguration {
     @Container
     static final GenericContainer<?> mongodbContainer = new GenericContainer<>(
             DockerImageName.parse("mongo:4.0.10"))
@@ -25,10 +27,24 @@ public class MongodbContainerConfiguration {
         mongodbContainer.start();
     }
 
-    @DynamicPropertySource
-    static void setProperties(DynamicPropertyRegistry registry) {
-        registry.add("spring.data.mongodb.uri", MongodbContainerConfiguration::getUri);
-        registry.add("spring.data.mongodb.database", () -> "SampleCollections");
+
+    @Bean
+    public RoutingMongoTemplate routingMongoTemplate() {
+       String mongoUri = MongoContainerConfiguration.getUri();
+       String databaseName = "SampleCollections";
+
+        RoutingMongoTemplate routingMongoTemplate = new RoutingMongoTemplate();
+
+        SimpleMongoClientDatabaseFactory simpleMongoClientDatabaseFactory =
+                new SimpleMongoClientDatabaseFactory(
+                        MongoClients.create(mongoUri), databaseName
+                );
+
+        MongoTemplate mongoTemplate = new MongoTemplate(simpleMongoClientDatabaseFactory);
+
+        routingMongoTemplate.add("mongo", mongoTemplate);
+
+        return routingMongoTemplate;
     }
 
     private static String getUri() {