MongoDB Integration

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>

# application.yml (local development)
spring:
  data:
    mongodb:
      uri: mongodb://appuser:${MONGO_PASSWORD}@localhost:27017/mydb?authSource=admin
      auto-index-creation: true

# application-prod.yml (MongoDB Atlas, SRV connection string, TLS is implied)
spring:
  data:
    mongodb:
      uri: mongodb+srv://appuser:${MONGO_PASSWORD}@cluster0.abc123.mongodb.net/mydb?retryWrites=true&w=majority

@Document(collection = "products")
public class Product {

    @Id
    private String id;

    private String name;
    private String description;

    @Field(targetType = FieldType.DECIMAL128)   // store as a decimal, not a String
    private BigDecimal price;

    private String category;
    private String sku;
    private boolean active = true;
    private List<String> tags = new ArrayList<>();

    private Address warehouseAddress;                       // embedded sub-document
    private List<ProductVariant> variants = new ArrayList<>(); // list of sub-documents
    private Map<String, String> attributes = new HashMap<>();  // free-form key/value

    @CreatedDate
    private LocalDateTime createdAt;

    @LastModifiedDate
    private LocalDateTime updatedAt;

    @Version
    private Long version;

    // getters and setters omitted
}

public record Address(String street, String city, String country) { }

public record ProductVariant(String sku, String colour, String size,
                             BigDecimal priceAdjustment) { }

// Enable auditing once, on any @Configuration class or the main class:
@SpringBootApplication
@EnableMongoAuditing
public class MyApplication { }

@Document(collection = "products")
@CompoundIndex(name = "idx_category_price", def = "{'category': 1, 'price': -1}")
public class Product {

    @Indexed(unique = true)
    private String sku;

    @Indexed
    private String category;

    @TextIndexed(weight = 2)      // name matches rank higher than description matches
    private String name;

    @TextIndexed
    private String description;

    // other fields as in the mapping section
}

// TTL index: MongoDB deletes the document once expiresAt + expireAfterSeconds has passed.
// With 0 it is deleted at the moment stored in expiresAt. The cleanup job runs about once a minute.
@Document(collection = "password_reset_tokens")
public class PasswordResetToken {

    @Id
    private String id;

    private String userId;

    @Indexed(expireAfterSeconds = 0)
    private Instant expiresAt;
}

@Repository
public interface ProductRepository extends MongoRepository<Product, String> {

    Optional<Product> findBySku(String sku);
    boolean existsBySku(String sku);
    long countByCategory(String category);

    List<Product> findByCategoryAndPriceLessThan(String category, BigDecimal max);
    List<Product> findByNameContainingIgnoreCase(String fragment);   // regex, no index use
    List<Product> findByVariantsSku(String sku);                     // nested field
    List<Product> findByActiveTrueOrderByPriceAsc();

    Page<Product> findByCategory(String category, Pageable pageable);

    @Query("{ 'price': { $gte: ?0, $lte: ?1 }, 'active': true }")
    List<Product> findActiveInPriceRange(BigDecimal min, BigDecimal max);

    // Projection: only load the listed fields
    @Query(value = "{ 'category': ?0 }", fields = "{ 'name': 1, 'price': 1, 'sku': 1 }")
    List<Product> findSummaryByCategory(String category);

    // Update-many in the database; returns how many documents changed
    @Query("{ 'category': ?0 }")
    @Update("{ '$set': { 'active': ?1 } }")
    long updateActiveByCategory(String category, boolean active);
}

@Service
public class ProductSearchService {

    private final MongoTemplate mongoTemplate;

    public ProductSearchService(MongoTemplate mongoTemplate) {
        this.mongoTemplate = mongoTemplate;
    }

    public Page<Product> search(ProductSearchRequest req, Pageable pageable) {
        List<Criteria> filters = new ArrayList<>();

        if (req.name() != null && !req.name().isBlank())
            filters.add(Criteria.where("name").regex(Pattern.quote(req.name()), "i"));
        if (req.category() != null)
            filters.add(Criteria.where("category").is(req.category()));
        if (req.minPrice() != null)
            filters.add(Criteria.where("price").gte(req.minPrice()));
        if (req.maxPrice() != null)
            filters.add(Criteria.where("price").lte(req.maxPrice()));
        if (req.tags() != null && !req.tags().isEmpty())
            filters.add(Criteria.where("tags").in(req.tags()));

        Criteria criteria = filters.isEmpty()
            ? new Criteria()
            : new Criteria().andOperator(filters.toArray(new Criteria[0]));

        Query query = new Query(criteria).with(pageable);   // pageable also carries the sort
        List<Product> content = mongoTemplate.find(query, Product.class);

        return PageableExecutionUtils.getPage(content, pageable,
            () -> mongoTemplate.count(Query.of(query).limit(-1).skip(-1), Product.class));
    }
}

public record ProductSearchRequest(String name, String category,
                                   BigDecimal minPrice, BigDecimal maxPrice,
                                   List<String> tags) { }

public List<CategorySummary> getCategorySummaries() {
    Aggregation agg = Aggregation.newAggregation(
        Aggregation.match(Criteria.where("active").is(true)),
        Aggregation.group("category")
            .count().as("productCount")
            .avg("price").as("averagePrice")
            .min("price").as("minPrice")
            .max("price").as("maxPrice"),
        Aggregation.sort(Sort.by(Sort.Direction.DESC, "productCount")),
        Aggregation.limit(10),
        Aggregation.project("productCount", "averagePrice", "minPrice", "maxPrice")
            .and("category").previousOperation()
            .andExclude("_id")
    );
    return mongoTemplate.aggregate(agg, Product.class, CategorySummary.class)
        .getMappedResults();
}

public record CategorySummary(String category, long productCount,
                              BigDecimal averagePrice, BigDecimal minPrice,
                              BigDecimal maxPrice) { }

public void upsertProduct(Product product) {
    Query query = Query.query(Criteria.where("sku").is(product.getSku()));
    Update update = new Update()
        .set("name", product.getName())
        .set("price", product.getPrice())
        .set("updatedAt", LocalDateTime.now())
        .setOnInsert("createdAt", LocalDateTime.now());
    mongoTemplate.upsert(query, update, Product.class);
}

public void bulkUpsert(List<Product> products) {
    if (products.isEmpty()) return;               // empty bulk operations throw
    BulkOperations ops = mongoTemplate.bulkOps(
        BulkOperations.BulkMode.UNORDERED, Product.class);
    for (Product p : products) {
        ops.upsert(
            Query.query(Criteria.where("sku").is(p.getSku())),
            new Update().set("name", p.getName()).set("price", p.getPrice()));
    }
    ops.execute();
}

@Configuration
public class MongoPoolConfig {

    @Bean
    MongoClientSettingsBuilderCustomizer mongoPoolCustomizer() {
        return builder -> builder
            .applyToConnectionPoolSettings(pool -> pool
                .maxSize(20)
                .minSize(5)
                .maxWaitTime(3, TimeUnit.SECONDS)
                .maxConnectionIdleTime(10, TimeUnit.MINUTES))
            .applyToSocketSettings(socket -> socket
                .connectTimeout(5, TimeUnit.SECONDS)
                .readTimeout(30, TimeUnit.SECONDS));
    }
}

# docker-compose.yml
services:
  mongodb:
    image: mongo:7
    container_name: myapp-mongo
    environment:
      MONGO_INITDB_ROOT_USERNAME: appuser
      MONGO_INITDB_ROOT_PASSWORD: apppassword
    ports:
      - "27017:27017"
    volumes:
      - mongo_data:/data/db

volumes:
  mongo_data:

<!-- pom.xml -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-testcontainers</artifactId>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.testcontainers</groupId>
    <artifactId>mongodb</artifactId>
    <scope>test</scope>
</dependency>

// Test class
@DataMongoTest(properties = "spring.data.mongodb.auto-index-creation=true")
@Testcontainers
class ProductRepositoryTest {

    @Container
    @ServiceConnection
    static MongoDBContainer mongo = new MongoDBContainer("mongo:7");

    @Autowired
    private ProductRepository productRepository;

    @Test
    void uniqueSkuIsEnforced() {
        productRepository.save(newProduct("SKU-1"));

        assertThatThrownBy(() -> productRepository.save(newProduct("SKU-1")))
            .isInstanceOf(DuplicateKeyException.class);
    }

    private static Product newProduct(String sku) {
        Product p = new Product();
        p.setSku(sku);
        p.setName("Widget");
        p.setPrice(new BigDecimal("9.99"));
        return p;
    }
}

// Check which indexes really exist (mongosh)
db.products.getIndexes()

// Fix for "Authentication failed": name the database holding the user
// spring.data.mongodb.uri: mongodb://appuser:${MONGO_PASSWORD}@localhost:27017/mydb?authSource=admin

// Embed: line items are small and always read with their order
@Document("orders")
public class Order {
    @Id private String id;
    private List<OrderLine> lines = new ArrayList<>();   // bounded, owned by the order
}

// Reference: a customer is shared by many orders and changes on its own
@Document("orders")
public class OrderWithCustomerRef {
    @Id private String id;
    private String customerId;                            // look up when needed
}