feat(spring-criteria): add support for not operator INTELLIJ-61 (#76)

Author: kmruiz

CHANGELOG.md

@@ -5,6 +5,8 @@ MongoDB plugin for IntelliJ IDEA.
 ## [Unreleased]
 
 ### Added
+* [INTELLIJ-61](https://jira.mongodb.org/browse/INTELLIJ-61) Add support for Spring Criteria
+  not operator, like in `where(field).not().is(value)`
 * [INTELLIJ-49](https://jira.mongodb.org/browse/INTELLIJ-49) Add support for Spring Criteria
 update operators.
 * [INTELLIJ-44](https://jira.mongodb.org/browse/INTELLIJ-44) Ability to load the Spring configuration from

packages/mongodb-dialects/mongosh/src/main/kotlin/com/mongodb/jbplugin/dialects/mongosh/MongoshDialectFormatter.kt

@@ -256,7 +256,7 @@ private fun <S> MongoshBackend.resolveValueReference(
 ) = when (val ref = valueRef.reference) {
     is HasValueReference.Constant -> registerConstant(ref.value)
     is HasValueReference.Runtime -> registerVariable(
-        (fieldRef?.reference as? HasFieldReference.Known)?.fieldName ?: "<value>",
+        (fieldRef?.reference as? HasFieldReference.Known)?.fieldName ?: "value",
         ref.type
     )
 

packages/mongodb-dialects/spring-criteria/src/main/kotlin/com/mongodb/jbplugin/dialects/springcriteria/SpringCriteriaDialectParser.kt

@@ -1,5 +1,6 @@
 package com.mongodb.jbplugin.dialects.springcriteria
 
+import com.intellij.database.dialects.base.introspector.listOf
 import com.intellij.psi.*
 import com.intellij.psi.util.elementType
 import com.intellij.psi.util.findParentOfType
@@ -319,13 +320,22 @@ object SpringCriteriaDialectParser : DialectParser<PsiElement> {
         }
 
         //                   v----------------------- field filter (it can be a where, an and...)
-        //                             v------------- valueMethodCall
-        //                                     v----- the value itself
-        // 2st scenario: $fieldRef$.$filter$("abc")
-        val fieldMethodCall =
+        //                            v--------------------- optional negation
+        //                                    v------------- valueMethodCall
+        //                                            v----- the value itself
+        // 2st scenario: $fieldRef$.$not$?.$filter$("abc")
+        var negate = false
+        var fieldMethodCall =
             valueMethodCall.firstChild.firstChild.meaningfulExpression() as? PsiMethodCallExpression
                 ?: return emptyList()
 
+        val fieldMethod = fieldMethodCall.fuzzyResolveMethod() ?: return emptyList()
+        if (fieldMethod.name == "not") {
+            negate = true
+            fieldMethodCall = fieldMethodCall.firstChild?.firstChild?.meaningfulExpression()
+                as? PsiMethodCallExpression ?: return emptyList()
+        }
+
         val fieldReference = inferFieldReference(fieldMethodCall)
         val valueReference = inferValueReference(valueMethodCall)
 
@@ -337,7 +347,7 @@ object SpringCriteriaDialectParser : DialectParser<PsiElement> {
         //                                 v------- fieldMethodCall is here
         // $nextFieldRef$.$nextValueRef$.$fieldRef$.$filter$("abc")
         val nextQueryExpression = fieldMethodCall.firstChild?.firstChild
-        val thisQueryNode = listOf(
+        var thisQueryNode = listOf(
             Node(
                 valueFilterExpression,
                 listOf(
@@ -347,6 +357,17 @@ object SpringCriteriaDialectParser : DialectParser<PsiElement> {
                 )
             )
         )
+        if (negate) {
+            thisQueryNode = listOf(
+                Node(
+                    valueFilterExpression,
+                    listOf(
+                        Named(Name.NOT),
+                        HasFilter(thisQueryNode)
+                    )
+                )
+            )
+        }
 
         if (nextQueryExpression != null && nextQueryExpression is PsiMethodCallExpression) {
             return thisQueryNode + parseFilterRecursively(nextQueryExpression)

packages/mongodb-dialects/spring-criteria/src/test/kotlin/com/mongodb/jbplugin/dialects/springcriteria/SpringCriteriaDialectParserTest.kt

@@ -739,4 +739,52 @@ class Repository {
             }
         }
     }
+
+    @ParsingTest(
+        fileName = "Book.java",
+        """
+import org.springframework.data.mongodb.core.MongoTemplate;
+import org.springframework.data.mongodb.core.mapping.Document;
+import org.springframework.data.mongodb.core.query.Criteria;
+import static org.springframework.data.mongodb.core.query.Criteria.where;
+import static org.springframework.data.mongodb.core.query.Query.query;
+import static org.springframework.data.mongodb.core.query.Update.update;
+
+import java.util.List;
+
+import static org.springframework.data.mongodb.core.query.Criteria.where;
+
+@Document
+record Book() {}
+
+class Repository {
+    private final MongoTemplate template;
+    
+    public Repository(MongoTemplate template) {
+        this.template = template;
+    }
+    
+    public Book randomBook() {
+        return template.find(query(where("field").not().is("123456")), Book.class);
+    }
+}
+        """
+    )
+    fun `supports not queries when prefixing the operation with not`(
+        psiFile: PsiFile
+    ) {
+        val query = psiFile.getQueryAtMethod("Repository", "randomBook")
+        SpringCriteriaDialectParser.parse(query).assert(IsCommand.CommandType.FIND_MANY) {
+            collection<HasCollectionReference.OnlyCollection<PsiElement>> {
+                assertEquals("book", collection)
+            }
+
+            filterN(0, Name.NOT) {
+                filterN(0, Name.EQ) {
+                    field<HasFieldReference.Known<PsiElement>> { assertEquals("field", fieldName) }
+                    value<HasValueReference.Constant<PsiElement>> { assertEquals("123456", value) }
+                }
+            }
+        }
+    }
 }