Merge pull request #576 from psteinroe/feat/invalidate

feat: add invalidateQueries

Author: psteinroe

.changeset/thick-ears-refuse.md

@@ -0,0 +1,5 @@
+---
+"@supabase-cache-helpers/postgrest-server": patch
+---
+
+feat: add invalidateQueries method

docs/pages/postgrest/server.mdx

@@ -171,3 +171,16 @@ const res = await cache.swr(
 );
 ```
 
+
+## Invalidating Queries
+
+To invaldiate all queries for a specific table, you can use the `invalidateQueries` method:
+
+
+```ts
+await cache.invalidateQueries({
+    schema: 'public',
+    table: 'contact',
+});
+```
+

packages/postgrest-server/src/key.ts

@@ -24,3 +24,7 @@ export function encode<Result>(
     parser.orderByKey,
   ].join(SEPARATOR);
 }
+
+export function buildTablePrefix(schema: string, table: string) {
+  return [schema, table].join(SEPARATOR);
+}

packages/postgrest-server/src/query-cache.ts

@@ -6,7 +6,7 @@ import type {
 } from '@supabase/postgrest-js';
 
 import { Context } from './context';
-import { encode } from './key';
+import { buildTablePrefix, encode } from './key';
 import { Value } from './stores/entry';
 import { Store } from './stores/interface';
 import { SwrCache } from './swr-cache';
@@ -44,6 +44,17 @@ export class QueryCache {
     });
   }
 
+  /**
+   * Invalidate all cache entries for a given table
+   */
+  async invalidateQueries({
+    schema,
+    table,
+  }: { schema: string; table: string }) {
+    const prefix = buildTablePrefix(schema, table);
+    return this.inner.removeByPrefix(prefix);
+  }
+
   /**
    * Perform a cached postgrest query
    */

packages/postgrest-server/src/stores/interface.ts

@@ -32,4 +32,9 @@ export interface Store {
    * Removes the key from the store.
    */
   remove(key: string | string[]): Promise<void>;
+
+  /**
+   * Removes all keys with the given prefix.
+   */
+  removeByPrefix(prefix: string): Promise<void>;
 }

packages/postgrest-server/src/stores/memory.ts

@@ -44,4 +44,12 @@ export class MemoryStore implements Store {
     }
     return Promise.resolve();
   }
+
+  public async removeByPrefix(prefix: string): Promise<void> {
+    for (const key of this.state.keys()) {
+      if (key.startsWith(prefix)) {
+        this.state.delete(key);
+      }
+    }
+  }
 }

packages/postgrest-server/src/stores/redis.ts

@@ -44,4 +44,24 @@ export class RedisStore implements Store {
     );
     this.redis.del(...cacheKeys);
   }
+
+  public async removeByPrefix(prefix: string): Promise<void> {
+    const pattern = `${prefix}*`;
+    let cursor = '0';
+
+    do {
+      const [nextCursor, keys] = await this.redis.scan(
+        cursor,
+        'MATCH',
+        pattern,
+        'COUNT',
+        100,
+      );
+      cursor = nextCursor;
+
+      if (keys.length > 0) {
+        await this.redis.del(...keys);
+      }
+    } while (cursor !== '0');
+  }
 }

packages/postgrest-server/src/swr-cache.ts

@@ -1,4 +1,3 @@
-import { PostgrestResponse } from '@supabase/postgrest-js';
 import type { Context } from './context';
 import { Value } from './stores/entry';
 import { Store } from './stores/interface';
@@ -27,6 +26,13 @@ export class SwrCache {
     this.stale = stale;
   }
 
+  /**
+   * Invalidate all keys that start with the given prefix
+   **/
+  async removeByPrefix(prefix: string) {
+    return this.store.removeByPrefix(prefix);
+  }
+
   /**
    * Return the cached value
    *

packages/postgrest-server/src/tiered-store.ts

@@ -71,4 +71,11 @@ export class TieredStore implements Store {
   public async remove(key: string): Promise<void> {
     await Promise.all(this.tiers.map((t) => t.remove(key)));
   }
+
+  /**
+   * Removes all keys with the given prefix.
+   */
+  public async removeByPrefix(prefix: string): Promise<void> {
+    await Promise.all(this.tiers.map((t) => t.removeByPrefix(prefix)));
+  }
 }

packages/postgrest-server/tests/query-cache.test.ts

@@ -350,6 +350,39 @@ describe('QueryCache', () => {
     });
   });
 
+  describe('.invalidateQueries()', () => {
+    it('should work', async () => {
+      const map = new Map();
+
+      const cache = new QueryCache(ctx, {
+        stores: [new MemoryStore({ persistentMap: map })],
+        fresh: 1000,
+        stale: 2000,
+      });
+
+      const query = client
+        .from('contact')
+        .select('id,username')
+        .eq('username', contacts[0].username!)
+        .single();
+
+      const spy = vi.spyOn(query, 'then');
+
+      const res = await cache.query(query);
+
+      await cache.invalidateQueries({
+        schema: 'public',
+        table: 'contact',
+      });
+
+      const res2 = await cache.query(query);
+
+      expect(res.data?.username).toEqual(contacts[0].username);
+      expect(res2.data?.username).toEqual(contacts[0].username);
+      expect(spy).toHaveBeenCalledTimes(2);
+    });
+  });
+
   it('should dedupe', async () => {
     const map = new Map();