Merge pull request #561 from psteinroe/fix/nested-arrays

fix(postgrest-core): handle nested arrays properly

Author: psteinroe

.changeset/tiny-bottles-wave.md

@@ -0,0 +1,5 @@
+---
+"@supabase-cache-helpers/postgrest-core": patch
+---
+
+fix: hasPath now handles nested arrays properly

packages/postgrest-core/src/postgrest-filter.ts

@@ -112,33 +112,33 @@ export class PostgrestFilter<Result extends Record<string, unknown>> {
     return this._selectFn(obj);
   }
 
-  private hasPathRecursive(
-    obj: unknown,
-    basePath: string,
-    objectPath?: string,
-  ): boolean {
-    const v = get(obj, basePath);
+  private hasPathRecursive(obj: unknown, path: string): boolean {
+    // normalise json operators "->" and "->>" to "."
+    const pathElements = path.replace(/->>|->/g, '.').split('.');
 
-    // Return early if we are not searching for a nested value and the path is valid
-    if (!objectPath && typeof v !== 'undefined') return true;
+    // we are at the deepest level
+    if (pathElements.length === 1) {
+      // obj is valid if v is null, because the foreign key relation can be null
+      if (obj === null) return true;
 
-    // If we are looking for a nested value and we found an array, validate that all array elements have a value for the required path
-    if (objectPath && Array.isArray(v)) {
-      return v.every((i) => typeof get(i, objectPath) !== 'undefined');
+      // else check if the path exists
+      return typeof get(obj, pathElements[0]) !== 'undefined';
     }
 
-    const pathElements = basePath.replace(/->>|->/g, '.').split('.');
-    const currentPathElement = pathElements.pop();
-
-    // Return if arrived at root level
-    // obj is valid if v is null, because the foreign key relation can be null
-    if (pathElements.length === 0) return v === null;
-    // If there are levels to go up to, add current path element to object path and go up
-    return this.hasPathRecursive(
-      obj,
-      pathElements.join('.'),
-      [currentPathElement, objectPath].filter(Boolean).join('.'),
-    );
+    // go deeper
+    const currentPathElement = pathElements.shift();
+    const v = get(obj, currentPathElement!);
+
+    // undefined means the path does not exist
+    if (typeof v === 'undefined') return false;
+
+    // if we have an array, check if all elements have the path
+    if (Array.isArray(v)) {
+      return v.every((i) => this.hasPathRecursive(i, pathElements.join('.')));
+    }
+
+    // if we dont have an array, continue recursively
+    return this.hasPathRecursive(v, pathElements.join('.'));
   }
 
   private applyFilterFn(

packages/postgrest-core/tests/postgrest-filter.spec.ts

@@ -10,6 +10,16 @@ const MOCK = {
   array: ['element-1', 'element-2'],
   empty_array: [],
   null_value: null,
+  array_within_array: [
+    {
+      val: 'hello',
+      inner_array: [
+        {
+          val: 'world',
+        },
+      ],
+    },
+  ],
   array_of_objects: [
     { some: { value: 'value' } },
     { some: { value: 'value' } },
@@ -535,6 +545,20 @@ describe('PostgrestFilter', () => {
       ).toEqual(true);
     });
 
+    it('with simple array', () => {
+      expect(
+        new PostgrestFilter({
+          filters: [],
+          paths: [
+            {
+              path: 'array',
+              declaration: 'array',
+            },
+          ],
+        }).hasPaths(MOCK),
+      ).toEqual(true);
+    });
+
     it('with valid array of objects', () => {
       expect(
         new PostgrestFilter({
@@ -562,6 +586,20 @@ describe('PostgrestFilter', () => {
         }).hasPaths(MOCK),
       ).toEqual(false);
     });
+
+    it('with nested arrays', () => {
+      expect(
+        new PostgrestFilter({
+          filters: [],
+          paths: [
+            {
+              path: 'array_within_array.inner_array.val',
+              declaration: 'array_within_array.inner_array.val',
+            },
+          ],
+        }).hasPaths(MOCK),
+      ).toEqual(true);
+    });
   });
 
   describe('.hasFiltersOnPaths', () => {