Merge pull request #167 from psteinroe/fix/mutate-with-pks-only

fix: only mutate with pks only, if the key either does not fitler on …

Author: psteinroe

.changeset/old-countries-bow.md

@@ -0,0 +1,6 @@
+---
+"@supabase-cache-helpers/postgrest-filter": patch
+"@supabase-cache-helpers/postgrest-mutate": patch
+---
+
+only mutate with pks only, if the key either does not fitler on pks, or the input matches all pk filters

packages/postgrest-filter/__tests__/lib/transform-recursive.spec.ts

@@ -1,6 +1,29 @@
 import { transformRecursive } from '../../src';
 
 describe('transformRecursive', () => {
+  it('should transform nulls to null', () => {
+    expect(
+      transformRecursive(
+        [
+          {
+            alias: 'id',
+            declaration: 'id',
+            path: 'id',
+          },
+          {
+            alias: 'full_name',
+            declaration: 'full_name:display_name',
+            path: 'display_name',
+          },
+        ],
+        {
+          id: null,
+          display_name: null,
+        },
+        'path'
+      )
+    ).toEqual({ id: null, display_name: null });
+  });
   it('should transform nulls of relation to null', () => {
     expect(
       transformRecursive(

packages/postgrest-filter/__tests__/postgrest-filter.spec.ts

@@ -354,6 +354,129 @@ describe('PostgrestFilter', () => {
       ).toEqual(false);
     });
   });
+
+  describe('.hasFiltersOnPaths', () => {
+    it('should return false if there is no filter on the given paths', () => {
+      expect(
+        new PostgrestFilter({
+          filters: [
+            {
+              or: [
+                {
+                  path: 'some_other_path',
+                  alias: 'text',
+                  negate: false,
+                  operator: 'eq',
+                  value: 'some-text',
+                },
+              ],
+            },
+          ],
+          paths: [
+            { path: 'text', declaration: 'text' },
+            { path: 'array', declaration: 'array' },
+            { path: 'some.nested.value', declaration: 'some.nested.value' },
+          ],
+        }).hasFiltersOnPaths(['some_path', 'some_unexisting_path'])
+      ).toEqual(false);
+    });
+    it('should return true if any path is included', () => {
+      expect(
+        new PostgrestFilter({
+          filters: [
+            {
+              or: [
+                {
+                  path: 'id',
+                  alias: undefined,
+                  negate: false,
+                  operator: 'eq',
+                  value: 1,
+                },
+                {
+                  path: 'some_other_path',
+                  alias: 'text',
+                  negate: false,
+                  operator: 'eq',
+                  value: 'some-text',
+                },
+              ],
+            },
+          ],
+          paths: [
+            { path: 'text', declaration: 'text' },
+            { path: 'array', declaration: 'array' },
+            { path: 'some.nested.value', declaration: 'some.nested.value' },
+          ],
+        }).hasFiltersOnPaths(['some_unexisting_path', 'id'])
+      ).toEqual(true);
+    });
+  });
+
+  describe('.applyFiltersOnPaths', () => {
+    it('with and', () => {
+      expect(
+        new PostgrestFilter({
+          filters: [
+            {
+              and: [
+                {
+                  path: 'some_other_path',
+                  alias: 'text',
+                  negate: false,
+                  operator: 'eq',
+                  value: 'some-text',
+                },
+                {
+                  path: 'id',
+                  negate: false,
+                  operator: 'eq',
+                  value: 5,
+                },
+              ],
+            },
+          ],
+          paths: [
+            { path: 'text', declaration: 'text' },
+            { path: 'array', declaration: 'array' },
+            { path: 'some.nested.value', declaration: 'some.nested.value' },
+          ],
+        }).applyFiltersOnPaths(MOCK, ['some_other_path'])
+      ).toEqual(true);
+    });
+    it('with or', () => {
+      expect(
+        new PostgrestFilter({
+          filters: [
+            {
+              or: [
+                {
+                  path: 'some_other_path',
+                  alias: 'text',
+                  negate: false,
+                  operator: 'eq',
+                  value: 'some-text-123',
+                },
+
+                {
+                  path: 'id',
+                  negate: false,
+                  operator: 'eq',
+                  value: 1,
+                },
+              ],
+            },
+          ],
+          paths: [
+            { path: 'text', declaration: 'text' },
+            { path: 'array', declaration: 'array' },
+            { path: 'some.nested.value', declaration: 'some.nested.value' },
+          ],
+        }).applyFiltersOnPaths(MOCK, ['some_other_path'])
+      ).toEqual(false);
+    });
+  });
+
   describe('.apply', () => {
     it('with alias', () => {
       expect(
@@ -368,6 +491,12 @@ describe('PostgrestFilter', () => {
                   operator: 'eq',
                   value: 'some-text',
                 },
+                {
+                  path: 'id',
+                  negate: false,
+                  operator: 'eq',
+                  value: 5,
+                },
               ],
             },
           ],

packages/postgrest-filter/src/lib/filter-filter-definitions-by-paths.ts

@@ -0,0 +1,28 @@
+import {
+  isAndFilter,
+  isOrFilter,
+  isFilterDefinition,
+  FilterDefinitions,
+} from './types';
+
+export const filterFilterDefinitionsByPaths = (
+  f: FilterDefinitions,
+  paths: string[]
+) => {
+  return f.reduce<FilterDefinitions>((prev, filter) => {
+    if (isAndFilter(filter)) {
+      const filters = filterFilterDefinitionsByPaths(filter.and, paths);
+      if (filters.length > 0) {
+        prev.push({ and: filters });
+      }
+    } else if (isOrFilter(filter)) {
+      const filters = filterFilterDefinitionsByPaths(filter.or, paths);
+      if (filters.length > 0) {
+        prev.push({ or: filters });
+      }
+    } else if (isFilterDefinition(filter) && paths.includes(filter.path)) {
+      prev.push(filter);
+    }
+    return prev;
+  }, []);
+};

packages/postgrest-filter/src/lib/index.ts

@@ -1,4 +1,5 @@
 export * from './extract-paths-from-filters';
+export * from './filter-filter-definitions-by-paths';
 export * from './group-paths-recursive';
 export * from './normalize';
 export * from './operators';

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

@@ -13,6 +13,7 @@ import {
   ValueType,
   extractPathsFromFilters,
   transformRecursive,
+  filterFilterDefinitionsByPaths,
 } from './lib';
 import {
   PostgrestQueryParser,
@@ -80,6 +81,22 @@ export class PostgrestFilter<Result extends Record<string, unknown>> {
     return this._filtersFn(obj);
   }
 
+  hasFiltersOnPaths(paths: string[]): boolean {
+    return (
+      filterFilterDefinitionsByPaths(this.params.filters, paths).length > 0
+    );
+  }
+
+  applyFiltersOnPaths(obj: unknown, paths: string[]): obj is Result {
+    const filterFns = filterFilterDefinitionsByPaths(
+      this.params.filters,
+      paths
+    ).map((d) => this.buildFilterFn(d));
+    const filtersFn = (obj: unknown): obj is Result =>
+      filterFns.every((fn) => isObject(obj) && fn(obj));
+    return filtersFn(obj);
+  }
+
   hasPaths(obj: unknown): obj is Result {
     if (!this._selectFn) {
       this._selectFn = (obj): obj is Result =>

packages/postgrest-mutate/__tests__/delete.spec.ts

@@ -27,6 +27,10 @@ describe('deleteItem', () => {
         },
         getPostgrestFilter() {
           return {
+            applyFiltersOnPaths: (obj: unknown): obj is ItemType => true,
+            hasFiltersOnPaths() {
+              return true;
+            },
             transform: (obj) => obj,
             apply(obj): obj is ItemType {
               return true;