implement Group stage

core/src/main/kotlin/com/github/inflab/spring/data/mongodb/core/aggregation/AggregationDsl.kt

@@ -277,6 +277,17 @@ class AggregationDsl {
         operations += Aggregation.limit(maxElements)
     }
 
+    /**
+     * Configures a stage that separates documents into groups according to a "group key".
+     * The output is one document for each unique group key.
+     *
+     * @param configuration The configuration block for the [GroupStageDsl].
+     * @see <a href="https://docs.mongodb.com/manual/reference/operator/aggregation/group">$group (aggregation)</a>
+     */
+    fun group(configuration: GroupStageDsl.() -> Unit) {
+        operations += GroupStageDsl().apply(configuration).build()
+    }
+
     /**
      * Builds the [Aggregation] using the configured [AggregationOperation]s.
      *

core/src/main/kotlin/com/github/inflab/spring/data/mongodb/core/aggregation/GroupStageDsl.kt

@@ -0,0 +1,77 @@
+package com.github.inflab.spring.data.mongodb.core.aggregation
+
+import com.github.inflab.spring.data.mongodb.core.aggregation.expression.AggregationExpressionDsl
+import com.github.inflab.spring.data.mongodb.core.annotation.AggregationMarker
+import com.github.inflab.spring.data.mongodb.core.extension.toDotPath
+import org.bson.Document
+import org.springframework.data.mongodb.core.aggregation.AggregationExpression
+import org.springframework.data.mongodb.core.aggregation.AggregationOperation
+import kotlin.reflect.KProperty
+
+/**
+ * A Kotlin DSL to configure $group stage using idiomatic Kotlin code.
+ *
+ * @author Jake Son
+ * @since 1.0
+ * @see <a href="https://docs.mongodb.com/manual/reference/operator/aggregation/group">$group (aggregation)</a>
+ */
+@AggregationMarker
+class GroupStageDsl {
+    private var document = Document()
+    private val accumulators: MutableMap<String, AggregationExpression> = mutableMapOf()
+
+    /**
+     * Specifies the group key to `null`.
+     * If you specify an _id value of null, or any other constant value, the $group stage returns a single document that aggregates values across all of the input documents.
+     */
+    fun idNull() {
+        document["_id"] = null
+    }
+
+    /**
+     * Specifies the group key to a field path.
+     *
+     * @param path The field name.
+     */
+    fun id(path: String) {
+        document["_id"] = "$$path"
+    }
+
+    /**
+     * Specifies the group key to a field path.
+     *
+     * @param property The property reference.
+     */
+    fun id(property: KProperty<*>) {
+        id(property.toDotPath())
+    }
+
+    /**
+     * Specifies the group key to an [AggregationExpression].
+     *
+     * @param configuration The configuration block for the [AggregationExpression].
+     */
+    fun id(configuration: AggregationExpressionDsl.() -> AggregationExpression) {
+        document["_id"] = AggregationExpressionDsl().configuration().toDocument()
+    }
+
+    /**
+     * Computed using the accumulator operators.
+     *
+     * @see <a href="https://www.mongodb.com/docs/manual/reference/operator/aggregation/group/#std-label-accumulators-group">accumulator operators</a>
+     */
+    infix fun String.accumulator(configuration: AggregationExpressionDsl.() -> AggregationExpression) {
+        accumulators[this] = AggregationExpressionDsl().configuration()
+    }
+
+    internal fun build() = AggregationOperation { context ->
+        (document["_id"] as? AggregationExpression)?.let {
+            document["_id"] = it.toDocument(context)
+        }
+        accumulators.forEach { (key, value) ->
+            document[key] = value.toDocument(context)
+        }
+
+        Document("\$group", document)
+    }
+}

core/src/main/kotlin/com/github/inflab/spring/data/mongodb/core/aggregation/expression/AggregationExpressionDsl.kt

@@ -5,6 +5,7 @@ import com.github.inflab.spring.data.mongodb.core.aggregation.expression.arithme
 import com.github.inflab.spring.data.mongodb.core.aggregation.expression.arithmetic.SubtractExpressionDsl
 import com.github.inflab.spring.data.mongodb.core.annotation.AggregationMarker
 import com.github.inflab.spring.data.mongodb.core.extension.toDotPath
+import org.bson.Document
 import org.springframework.data.mongodb.core.aggregation.AggregationExpression
 import org.springframework.data.mongodb.core.aggregation.ArithmeticOperators
 import kotlin.reflect.KProperty
@@ -155,4 +156,11 @@ class AggregationExpressionDsl {
      */
     fun subtract(configuration: SubtractExpressionDsl.() -> AggregationExpression): AggregationExpression =
         SubtractExpressionDsl().configuration()
+
+    /**
+     * Returns the number of documents in a group.
+     */
+    fun count() = AggregationExpression {
+        Document("\$count", Document())
+    }
 }

core/src/test/kotlin/com/github/inflab/spring/data/mongodb/core/aggregation/AggregationDslTest.kt

@@ -313,4 +313,20 @@ internal class AggregationDslTest : FreeSpec({
             ).toString()
         }
     }
+
+    "group" - {
+        "should create group stage" {
+            // when
+            val aggregation = aggregation {
+                group {
+                    idNull()
+                }
+            }
+
+            // then
+            aggregation.toString() shouldBe Aggregation.newAggregation(
+                Aggregation.group(),
+            ).toString()
+        }
+    }
 })

core/src/test/kotlin/com/github/inflab/spring/data/mongodb/core/aggregation/GroupStageDslTest.kt

@@ -0,0 +1,128 @@
+package com.github.inflab.spring.data.mongodb.core.aggregation
+
+import com.github.inflab.spring.data.mongodb.core.util.shouldBeJson
+import io.kotest.core.spec.style.FreeSpec
+
+internal class GroupStageDslTest : FreeSpec({
+    fun group(block: GroupStageDsl.() -> Unit) =
+        GroupStageDsl().apply(block)
+
+    "_id" - {
+        "should build by null" {
+            // when
+            val stage = group {
+                idNull()
+            }
+
+            // then
+            val result = stage.build()
+
+            // then
+            result.shouldBeJson(
+                """
+                {
+                  "${'$'}group": {
+                    "_id": null
+                  }
+                }
+                """.trimIndent(),
+            )
+        }
+
+        "should build by string" {
+            // given
+            val path = "path"
+            val stage = group {
+                id(path)
+            }
+
+            // when
+            val result = stage.build()
+
+            // then
+            result.shouldBeJson(
+                """
+                {
+                  "${'$'}group": {
+                    "_id": "${'$'}path"
+                  }
+                }
+                """.trimIndent(),
+            )
+        }
+
+        "should build by property" {
+            // given
+            data class Test(val property: String)
+            val stage = group {
+                id(Test::property)
+            }
+
+            // when
+            val result = stage.build()
+
+            // then
+            result.shouldBeJson(
+                """
+                {
+                  "${'$'}group": {
+                    "_id": "${'$'}property"
+                  }
+                }
+                """.trimIndent(),
+            )
+        }
+
+        "should build by expression" {
+            // given
+            val stage = group {
+                id {
+                    abs("field")
+                }
+            }
+
+            // when
+            val result = stage.build()
+
+            // then
+            result.shouldBeJson(
+                """
+                {
+                  "${'$'}group": {
+                    "_id": {
+                      "${'$'}abs": "${'$'}field"
+                    }
+                  }
+                }
+                """.trimIndent(),
+            )
+        }
+    }
+
+    "accumulator" - {
+        "should build by expression" {
+            // given
+            val stage = group {
+                "amount" accumulator {
+                    abs("field")
+                }
+            }
+
+            // when
+            val result = stage.build()
+
+            // then
+            result.shouldBeJson(
+                """
+                {
+                  "${'$'}group": {
+                    "amount": {
+                      "${'$'}abs": "${'$'}field"
+                    }
+                  }
+                }
+                """.trimIndent(),
+            )
+        }
+    }
+})

core/src/test/kotlin/com/github/inflab/spring/data/mongodb/core/aggregation/expression/AggregationExpressionDslTest.kt

@@ -303,4 +303,20 @@ internal class AggregationExpressionDslTest : FreeSpec({
             )
         }
     }
+
+    "count" - {
+        "should build an expression" {
+            // when
+            val result = expression { count() }
+
+            // then
+            result.shouldBeJson(
+                """
+                {
+                  "${'$'}count": {}
+                }
+                """.trimIndent(),
+            )
+        }
+    }
 })