Merge pull request #64 from ergon/feature/dope-239-object-funcitons

DOPE-239: implemented all objectFunctions with extensions for cm and added tests

Author: pgruntz

core/src/integrationTest/kotlin/ch/ergon/dope/clauses/SelectQueryIntegrationTest.kt

@@ -257,6 +257,10 @@ class SelectQueryIntegrationTest : BaseIntegrationTest() {
 
     @Test
     fun `select with star expression`() {
+        val contacts = listOf(
+            mapOf("email" to "[email protected]", "name" to "Contact A"),
+            mapOf("email" to "[email protected]", "name" to "Contact B"),
+        )
         val dopeQuery = QueryBuilder()
             .select(
                 testBucket.asterisk(),
@@ -271,7 +275,13 @@ class SelectQueryIntegrationTest : BaseIntegrationTest() {
 
         val queryResult = queryWithoutParameters(dopeQuery)
 
-        assertEquals(mapOf("id" to 2, "isActive" to true, "name" to "client2", "type" to "client"), queryResult.toMapValues(rowNumber = 0))
-        assertEquals(mapOf("id" to 4, "isActive" to true, "name" to "client4", "type" to "client"), queryResult.toMapValues(rowNumber = 1))
+        assertEquals(
+            mapOf("id" to 2, "isActive" to true, "name" to "client2", "type" to "client", "contacts" to contacts),
+            queryResult.toMapValues(rowNumber = 0),
+        )
+        assertEquals(
+            mapOf("id" to 4, "isActive" to true, "name" to "client4", "type" to "client", "contacts" to contacts),
+            queryResult.toMapValues(rowNumber = 1),
+        )
     }
 }

core/src/integrationTest/kotlin/ch/ergon/dope/clauses/UpdateIntegrationTest.kt

@@ -26,21 +26,21 @@ class UpdateIntegrationTest : BaseIntegrationTest() {
 
     @Test
     fun `update to set and unset single attribute`() {
-        val newField = Field<StringType>("newField", testBucket.name)
+        val newFieldName = Field<StringType>("newFieldName", testBucket.name)
         val newNullField = Field<NumberType>("nullField", testBucket.name)
         val dopeQuery = QueryBuilder()
             .update(
                 testBucket.useKeys("client:1"),
             )
             .set(
-                newField.toNewValue("newName"),
+                newFieldName.toNewValue("newName"),
                 newNullField.toNewValue(NULL),
             )
             .unset(
                 nameField,
             )
             .returning(
-                newField,
+                newFieldName,
                 newNullField,
                 nameField,
             )
@@ -50,7 +50,7 @@ class UpdateIntegrationTest : BaseIntegrationTest() {
             val queryResult = queryWithoutParameters(dopeQuery)
             val result = queryResult.toMapValues()
 
-            assertEquals("newName", result["newField"])
+            assertEquals("newName", result["newFieldName"])
             assertNull(result["nullField"])
             assertNull(result["nameField"])
         }

core/src/integrationTest/kotlin/ch/ergon/dope/functions/ObjectFunctionsIntegrationTest.kt

@@ -0,0 +1,52 @@
+package ch.ergon.dope.functions
+
+import ch.ergon.dope.QueryBuilder
+import ch.ergon.dope.integrationTest.BaseIntegrationTest
+import ch.ergon.dope.integrationTest.TestCouchbaseDatabase.detailsField
+import ch.ergon.dope.integrationTest.TestCouchbaseDatabase.testBucket
+import ch.ergon.dope.integrationTest.toMapValues
+import ch.ergon.dope.resolvable.expression.type.TRUE
+import ch.ergon.dope.resolvable.expression.type.alias
+import ch.ergon.dope.resolvable.expression.type.collection.inArray
+import ch.ergon.dope.resolvable.expression.type.function.objects.addAttribute
+import ch.ergon.dope.resolvable.expression.type.function.objects.concat
+import ch.ergon.dope.resolvable.expression.type.function.objects.getInnerPairs
+import ch.ergon.dope.resolvable.expression.type.function.objects.getLength
+import ch.ergon.dope.resolvable.expression.type.function.objects.removeAttribute
+import ch.ergon.dope.resolvable.expression.type.logic.and
+import ch.ergon.dope.resolvable.expression.type.meta
+import ch.ergon.dope.resolvable.expression.type.relational.isGreaterThan
+import ch.ergon.dope.resolvable.expression.type.toDopeType
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class ObjectFunctionsIntegrationTest : BaseIntegrationTest() {
+    @Test
+    fun `use nested object functions`() {
+        val dopeQuery = QueryBuilder()
+            .selectRaw(
+                detailsField.concat(mapOf("someField" to 4).toDopeType()).addAttribute("otherField", TRUE).removeAttribute("department")
+                    .alias("result"),
+            )
+            .from(testBucket)
+            .where(
+                detailsField.getLength().isGreaterThan(2)
+                    .and(mapOf("name" to "email", "val" to "[email protected]").toDopeType().inArray(detailsField.getInnerPairs())),
+            ).orderBy(
+                meta().id,
+            )
+            .build()
+
+        val queryResult = queryWithoutParameters(dopeQuery)
+
+        assertEquals(
+            mapOf(
+                "position" to "Engineer",
+                "email" to "[email protected]",
+                "someField" to 4,
+                "otherField" to true,
+            ),
+            queryResult.toMapValues(),
+        )
+    }
+}

core/src/integrationTest/kotlin/ch/ergon/dope/integrationTest/TestCouchbaseDatabase.kt

@@ -7,6 +7,7 @@ import ch.ergon.dope.resolvable.expression.type.Field
 import ch.ergon.dope.validtype.ArrayType
 import ch.ergon.dope.validtype.BooleanType
 import ch.ergon.dope.validtype.NumberType
+import ch.ergon.dope.validtype.ObjectType
 import ch.ergon.dope.validtype.StringType
 import com.couchbase.client.kotlin.Cluster
 import com.couchbase.client.kotlin.query.QueryResult
@@ -33,6 +34,7 @@ object TestCouchbaseDatabase {
     val orderNumberField = Field<StringType>("orderNumber", testBucket.name)
     val deliveryDateField = Field<StringType>("deliveryDate", testBucket.name)
     val quantitiesField = Field<ArrayType<NumberType>>("quantities", testBucket.name)
+    val detailsField = Field<ObjectType>("details", testBucket.name)
 
     init {
         initContainer()
@@ -69,6 +71,11 @@ object TestCouchbaseDatabase {
                             "type" to "employee",
                             "name" to "employee$i",
                             "isActive" to true,
+                            "details" to mapOf(
+                                "position" to "Engineer",
+                                "department" to "Engineering",
+                                "email" to "employee$i@company.com",
+                            ),
                         ),
                     )
                     collection.upsert(
@@ -78,6 +85,10 @@ object TestCouchbaseDatabase {
                             "type" to "client",
                             "name" to "client$i",
                             "isActive" to (i % 2 == 0), // clients with even numbers are active
+                            "contacts" to listOf(
+                                mapOf("name" to "Contact A", "email" to "[email protected]"),
+                                mapOf("name" to "Contact B", "email" to "[email protected]"),
+                            ),
                         ),
                     )
                     collection.upsert(

core/src/main/kotlin/ch/ergon/dope/resolvable/expression/type/Primitive.kt

@@ -76,8 +76,8 @@ class ObjectPrimitive(
 )
 
 class ObjectEntryPrimitive<T : ValidType>(
-    private val key: TypeExpression<StringType>,
-    private val value: TypeExpression<T>,
+    val key: TypeExpression<StringType>,
+    val value: TypeExpression<T>,
 ) : Resolvable {
     override fun toDopeQuery(manager: DopeQueryManager): DopeQuery {
         val keyQuery = key.toDopeQuery(manager)

core/src/main/kotlin/ch/ergon/dope/resolvable/expression/type/function/objects/ObjectAddExpression.kt

@@ -0,0 +1,24 @@
+package ch.ergon.dope.resolvable.expression.type.function.objects
+
+import ch.ergon.dope.resolvable.expression.type.ObjectEntryPrimitive
+import ch.ergon.dope.resolvable.expression.type.TypeExpression
+import ch.ergon.dope.resolvable.expression.type.function.FunctionExpression
+import ch.ergon.dope.resolvable.expression.type.toDopeType
+import ch.ergon.dope.resolvable.expression.type.toObjectEntry
+import ch.ergon.dope.validtype.ObjectType
+import ch.ergon.dope.validtype.StringType
+import ch.ergon.dope.validtype.ValidType
+
+class ObjectAddExpression(
+    objectExpression: TypeExpression<ObjectType>,
+    objectEntryPrimitive: ObjectEntryPrimitive<out ValidType>,
+) : FunctionExpression<ObjectType>("OBJECT_ADD", objectExpression, objectEntryPrimitive.key, objectEntryPrimitive.value)
+
+fun TypeExpression<ObjectType>.addAttribute(objectEntryPrimitive: ObjectEntryPrimitive<out ValidType>) =
+    ObjectAddExpression(this, objectEntryPrimitive)
+
+fun TypeExpression<ObjectType>.addAttribute(key: TypeExpression<StringType>, value: TypeExpression<out ValidType>) =
+    addAttribute(key.toObjectEntry(value))
+
+fun TypeExpression<ObjectType>.addAttribute(key: String, value: TypeExpression<out ValidType>) =
+    addAttribute(key.toDopeType(), value)

core/src/main/kotlin/ch/ergon/dope/resolvable/expression/type/function/objects/ObjectConcatExpression.kt

@@ -0,0 +1,16 @@
+package ch.ergon.dope.resolvable.expression.type.function.objects
+
+import ch.ergon.dope.resolvable.expression.type.TypeExpression
+import ch.ergon.dope.resolvable.expression.type.function.FunctionExpression
+import ch.ergon.dope.validtype.ObjectType
+
+class ObjectConcatExpression(
+    firstObjectExpression: TypeExpression<ObjectType>,
+    secondObjectExpression: TypeExpression<ObjectType>,
+    vararg additionalObjectExpression: TypeExpression<ObjectType>,
+) : FunctionExpression<ObjectType>("OBJECT_CONCAT", firstObjectExpression, secondObjectExpression, *additionalObjectExpression)
+
+fun TypeExpression<ObjectType>.concat(
+    secondObjectExpression: TypeExpression<ObjectType>,
+    vararg additionalObjectExpression: TypeExpression<ObjectType>,
+) = ObjectConcatExpression(this, secondObjectExpression, *additionalObjectExpression)

core/src/main/kotlin/ch/ergon/dope/resolvable/expression/type/function/objects/ObjectFieldExpression.kt

@@ -0,0 +1,18 @@
+package ch.ergon.dope.resolvable.expression.type.function.objects
+
+import ch.ergon.dope.resolvable.expression.type.TypeExpression
+import ch.ergon.dope.resolvable.expression.type.function.FunctionExpression
+import ch.ergon.dope.resolvable.expression.type.toDopeType
+import ch.ergon.dope.validtype.ObjectType
+import ch.ergon.dope.validtype.StringType
+import ch.ergon.dope.validtype.ValidType
+
+class ObjectFieldExpression(
+    objectExpression: TypeExpression<ObjectType>,
+    attributeKey: TypeExpression<StringType>,
+) : FunctionExpression<ValidType>("OBJECT_FIELD", objectExpression, attributeKey)
+
+fun TypeExpression<ObjectType>.getField(key: TypeExpression<StringType>) =
+    ObjectFieldExpression(this, key)
+
+fun TypeExpression<ObjectType>.getField(key: String) = getField(key.toDopeType())

core/src/main/kotlin/ch/ergon/dope/resolvable/expression/type/function/objects/ObjectInnerPairsExpression.kt

@@ -0,0 +1,12 @@
+package ch.ergon.dope.resolvable.expression.type.function.objects
+
+import ch.ergon.dope.resolvable.expression.type.TypeExpression
+import ch.ergon.dope.resolvable.expression.type.function.FunctionExpression
+import ch.ergon.dope.validtype.ArrayType
+import ch.ergon.dope.validtype.ObjectType
+
+class ObjectInnerPairsExpression(
+    objectExpression: TypeExpression<ObjectType>,
+) : FunctionExpression<ArrayType<ObjectType>>("OBJECT_INNER_PAIRS", objectExpression)
+
+fun TypeExpression<ObjectType>.getInnerPairs() = ObjectInnerPairsExpression(this)

core/src/main/kotlin/ch/ergon/dope/resolvable/expression/type/function/objects/ObjectInnerValuesExpression.kt

@@ -0,0 +1,13 @@
+package ch.ergon.dope.resolvable.expression.type.function.objects
+
+import ch.ergon.dope.resolvable.expression.type.TypeExpression
+import ch.ergon.dope.resolvable.expression.type.function.FunctionExpression
+import ch.ergon.dope.validtype.ArrayType
+import ch.ergon.dope.validtype.ObjectType
+import ch.ergon.dope.validtype.ValidType
+
+class ObjectInnerValuesExpression(
+    objectExpression: TypeExpression<ObjectType>,
+) : FunctionExpression<ArrayType<ValidType>>("OBJECT_INNER_VALUES", objectExpression)
+
+fun TypeExpression<ObjectType>.getInnerValues() = ObjectInnerValuesExpression(this)