Merge pull request #150 from alexovn/fix/logical-operator-not-inside-nested-prop

Author: techniq

.changeset/happy-games-greet.md

@@ -0,0 +1,5 @@
+---
+"odata-query": patch
+---
+
+- fix: resolve an issue with logical operator "not" inside nested property ([#98](https://github.com/techniq/odata-query/issues/98))

src/index.ts

@@ -303,7 +303,13 @@ function buildFilter<T>(filters: Filter<T> = {}, aliases: Alias[] = [], propPref
                   result.push(`${op}(${propName},${handleValue(value[op], aliases)})`);
                 } else {
                   // Nested property
-                  const filter = buildFilterCore({ [op]: value[op] }, aliases, propName);
+                  const isPropNameContainsNot = /\/not/g.test(propName)
+                  let internalPropName = isPropNameContainsNot ? propName.replace(/\/not/g, '') : propName
+
+                  const filter = isPropNameContainsNot
+                    ? parseNot([buildFilterCore({ [op]: value[op] }, aliases, internalPropName)])
+                    : buildFilterCore({ [op]: value[op] }, aliases, internalPropName)
+
                   if (filter) {
                     result.push(filter);
                   }

test/index.test.ts

@@ -164,6 +164,17 @@ describe('filter', () => {
   });
 
   describe('logical operators', () => {
+    it('should handle simple logical operators (not)', () => {
+      const filter = {
+        not: { FooProp: { startswith: 'foo' } }
+      };
+      const expected =
+        "?$filter=not (startswith(FooProp,'foo'))";
+      const actual = buildQuery({ filter });
+      expect(actual).toEqual(expected);
+    });
+    
+    
     it('should handle simple logical operators (not) as an object', () => {
       const filter = {
         and: [
@@ -173,7 +184,24 @@ describe('filter', () => {
         ],
       };
       const expected =
-        "?$filter=((not (startswith(FooProp,'foo'))) and (not (startswith(BarProp,'bar'))) and (startswith(FooBarProp,'foobar')))";
+      "?$filter=((not (startswith(FooProp,'foo'))) and (not (startswith(BarProp,'bar'))) and (startswith(FooBarProp,'foobar')))";
+      const actual = buildQuery({ filter });
+      expect(actual).toEqual(expected);
+    });
+    
+    it('should handle simple logical operators (not) inside nested prop', () => {
+      const filter = {
+        Prop: {
+          all: {
+            and: [
+              { not: { FooProp: { contains: "foo" } } },
+              { BarProp: { contains: "bar" }},
+            ],
+          },
+        },
+      };
+      const expected =
+        "?$filter=Prop/all(prop:((not (contains(prop/FooProp,'foo'))) and (contains(prop/BarProp,'bar'))))";
       const actual = buildQuery({ filter });
       expect(actual).toEqual(expected);
     });