Implement $addFields stage dsl

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

@@ -0,0 +1,94 @@
+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.springframework.data.mongodb.core.aggregation.AddFieldsOperation
+import org.springframework.data.mongodb.core.aggregation.AggregationExpression
+import kotlin.reflect.KProperty
+
+/**
+ * A Kotlin DSL to configure $addFields stage using idiomatic Kotlin code.
+ *
+ * @author username1103
+ * @since 1.0
+ * @see <a href="https://www.mongodb.com/docs/v7.0/reference/operator/aggregation/addFields">$addFields (aggregation)</a>
+ */
+@AggregationMarker
+class AddFieldsStageDsl {
+    private val builder = AddFieldsOperation.builder()
+
+    /**
+     * Adds new fields to documents with aggregation expression.
+     *
+     * @param configuration The configuration block where you can use DSL to define aggregation expression.
+     */
+    infix fun String.set(configuration: AggregationExpressionDsl.() -> AggregationExpression) {
+        builder.addField(this).withValue(AggregationExpressionDsl().configuration())
+    }
+
+    /**
+     * Adds new fields to documents from a field.
+     *
+     * @param path The path of the field to contain value to be added.
+     */
+    infix fun String.set(path: KProperty<Any?>) {
+        builder.addField(this).withValue("${'$'}${path.toDotPath()}")
+    }
+
+    /**
+     * Adds new fields to documents with a value.
+     *
+     * @param value The value of the field to add.
+     */
+    infix fun String.set(value: Any?) {
+        builder.addField(this).withValue(value)
+    }
+
+    /**
+     * Adds new fields to documents from a field.
+     *
+     * @param fieldPath The path of the field to contain value to be added.
+     */
+    infix fun String.setByField(fieldPath: String) {
+        builder.addField(this).withValue("$$fieldPath")
+    }
+
+    /**
+     * Adds new fields to documents with aggregation expression.
+     *
+     * @param configuration The configuration block where you can use DSL to define aggregation expression.
+     */
+    infix fun KProperty<Any?>.set(configuration: AggregationExpressionDsl.() -> AggregationExpression) {
+        builder.addField(this.toDotPath()).withValue(AggregationExpressionDsl().configuration())
+    }
+
+    /**
+     * Adds new fields to documents from a field.
+     *
+     * @param path The path of the field to contain value to be added.
+     */
+    infix fun KProperty<Any?>.set(path: KProperty<Any?>) {
+        builder.addField(this.toDotPath()).withValue("${'$'}${path.toDotPath()}")
+    }
+
+    /**
+     * Adds new fields to documents with a value.
+     *
+     * @param value The value of the field to add.
+     */
+    infix fun KProperty<Any?>.set(value: Any?) {
+        builder.addField(this.toDotPath()).withValue(value)
+    }
+
+    /**
+     * Adds new fields to documents from a field.
+     *
+     * @param fieldPath The path of the field to contain value to be added.
+     */
+    infix fun KProperty<Any?>.setByField(fieldPath: String) {
+        builder.addField(this.toDotPath()).withValue("$$fieldPath")
+    }
+
+    internal fun get() = builder.build()
+}

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

@@ -288,6 +288,16 @@ class AggregationDsl {
         operations += GroupStageDsl().apply(configuration).build()
     }
 
+    /**
+     * Configures a stage that add fields in documents.
+     *
+     * @param configuration The configuration block for the [AddFieldsStageDsl].
+     * @see <a href="https://docs.mongodb.com/manual/reference/operator/aggregation/addFields">$addFields (aggregation)</a>
+     */
+    fun addFields(configuration: AddFieldsStageDsl.() -> Unit) {
+        operations += AddFieldsStageDsl().apply(configuration).get()
+    }
+
     /**
      * Builds the [Aggregation] using the configured [AggregationOperation]s.
      *

core/src/main/kotlin/com/github/inflab/spring/data/mongodb/core/mapping/KPropertyPath.kt

@@ -1,5 +1,6 @@
 package com.github.inflab.spring.data.mongodb.core.mapping
 
+import org.springframework.data.annotation.Id
 import org.springframework.data.mongodb.core.mapping.Field
 import kotlin.reflect.KProperty
 import kotlin.reflect.KProperty1
@@ -30,16 +31,36 @@ internal fun asString(property: KProperty<*>): String =
     }
 
 /**
- * Get field name from [Field] annotation or property name.
+ * Get field name from [Field] annotation, [Id] annotation or property name.
  *
  * @param property property to get field name from
  * @author Jake Son
  * @since 1.0
  */
+@Suppress("detekt:style:ReturnCount")
 internal fun toFieldName(property: KProperty<*>): String {
-    val fieldAnnotation = property.javaField?.getAnnotation(Field::class.java) ?: return property.name
+    val idAnnotation = property.javaField?.getAnnotation(Id::class.java)
+    if (idAnnotation != null) {
+        return "_id"
+    }
+
+    val fieldAnnotation = property.javaField?.getAnnotation(Field::class.java)
+
+    if (fieldAnnotation != null) {
+        if (fieldAnnotation.value.isNotEmpty()) {
+            return fieldAnnotation.value
+        }
+
+        if (fieldAnnotation.name.isNotEmpty()) {
+            return fieldAnnotation.name
+        }
+    }
+
+    if (property.name == "id") {
+        return "_id"
+    }
 
-    return fieldAnnotation.value.ifEmpty { fieldAnnotation.name.ifEmpty { property.name } }
+    return property.name
 }
 
 /**

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

@@ -0,0 +1,204 @@
+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 AddFieldsStageDslTest : FreeSpec({
+
+    fun addFields(configuration: AddFieldsStageDsl.() -> Unit): AddFieldsStageDsl =
+        AddFieldsStageDsl().apply(configuration)
+
+    "set" - {
+        "should set field with path" {
+            // given
+            data class Test(val targetPath: Int)
+            val stage = addFields {
+                "a" set Test::targetPath
+            }
+
+            // when
+            val result = stage.get()
+
+            // then
+            result.shouldBeJson(
+                """
+                {
+                  "${'$'}addFields": {
+                    "a": "${'$'}targetPath"
+                  }
+                }
+                """.trimIndent(),
+            )
+        }
+
+        "should set field path with path" {
+            // given
+            data class Test(val sourcePath: Int, val targetPath: Int)
+            val stage = addFields {
+                Test::targetPath set Test::sourcePath
+            }
+
+            // when
+            val result = stage.get()
+
+            // then
+            result.shouldBeJson(
+                """
+                {
+                  "${'$'}addFields": {
+                    "targetPath": "${'$'}sourcePath"
+                  }
+                }
+                """.trimIndent(),
+            )
+        }
+
+        "should set field with aggregation expression" {
+            // given
+            data class Test(val targetPath: Int)
+            val stage = addFields {
+                "a" set {
+                    add { of(1) and 2 and Test::targetPath }
+                }
+            }
+
+            // when
+            val result = stage.get()
+
+            // then
+            result.shouldBeJson(
+                """
+                {
+                  "${'$'}addFields": {
+                    "a": {
+                      "${'$'}add": [
+                        1,
+                        2,
+                        "${'$'}targetPath"
+                      ]
+                    }
+                  }
+                }
+                """.trimIndent(),
+            )
+        }
+
+        "should set field path with aggregation expression" {
+            // given
+            data class Test(val sourcePath: Int, val targetPath: Int)
+            val stage = addFields {
+                Test::targetPath set {
+                    add { of(1) and 2 and Test::sourcePath }
+                }
+            }
+
+            // when
+            val result = stage.get()
+
+            // then
+            result.shouldBeJson(
+                """
+                {
+                  "${'$'}addFields": {
+                    "targetPath": {
+                      "${'$'}add": [
+                        1,
+                        2,
+                        "${'$'}sourcePath"
+                      ]
+                    }
+                  }
+                }
+                """.trimIndent(),
+            )
+        }
+
+        "should set field with value" {
+            // given
+            val stage = addFields {
+                "a" set 1
+            }
+
+            // when
+            val result = stage.get()
+
+            // then
+            result.shouldBeJson(
+                """
+                {
+                  "${'$'}addFields": {
+                    "a": 1
+                  }
+                }
+                """.trimIndent(),
+            )
+        }
+
+        "should set field path with value" {
+            // given
+            data class Test(val targetPath: Int)
+            val stage = addFields {
+                Test::targetPath set 1
+            }
+
+            // when
+            val result = stage.get()
+
+            // then
+            result.shouldBeJson(
+                """
+                {
+                  "${'$'}addFields": {
+                    "targetPath": 1
+                  }
+                }
+                """.trimIndent(),
+            )
+        }
+    }
+
+    "setByField" - {
+        "should set field with value of other field" {
+            // given
+            val stage = addFields {
+                "a" setByField "b"
+            }
+
+            // when
+            val result = stage.get()
+
+            // then
+            result.shouldBeJson(
+                """
+                {
+                  "${'$'}addFields": {
+                    "a": "${'$'}b"
+                  }
+                }
+                """.trimIndent(),
+            )
+        }
+
+        "should set field path with value of other field" {
+            // given
+            data class Test(val targetPath: Int)
+            val stage = addFields {
+                Test::targetPath setByField "b"
+            }
+
+            // when
+            val result = stage.get()
+
+            // then
+            result.shouldBeJson(
+                """
+                {
+                  "${'$'}addFields": {
+                    "targetPath": "${'$'}b"
+                  }
+                }
+                """.trimIndent(),
+            )
+        }
+    }
+})