swr support

Author: sanny-io

packages/plugins/cache/src/plugin.ts

@@ -3,9 +3,13 @@ import { definePlugin } from '@zenstackhq/orm';
 import stableStringify from 'json-stable-stringify';
 import murmurhash from 'murmurhash';
 import { cacheEnvelopeSchema } from './schemas';
-import type { CacheEnvelope, CacheInvalidationOptions, CachePluginOptions } from './types';
+import type { CacheEnvelope, CacheInvalidationOptions, CachePluginOptions, CacheStatus } from './types';
+import { entryIsFresh, entryIsStale } from './utils'
 
 export function defineCachePlugin(pluginOptions: CachePluginOptions) {
+    let status: CacheStatus | null = null;
+    let revalidation: Promise<void> | null = null;
+
     return definePlugin({
         id: 'cache',
         name: 'Cache',
@@ -24,6 +28,23 @@ export function defineCachePlugin(pluginOptions: CachePluginOptions) {
                 invalidateAll() {
                     return pluginOptions.provider.invalidateAll();
                 },
+
+                /**
+                 * Returns the status of the last result returned, or `null`
+                 * if a result has yet to be returned.
+                 */
+                get status() {
+                    return status;
+                },
+
+                /**
+                 * Returns a `Promise` that fulfills when the last stale result
+                 * returned has been revalidated, or `null` if a stale result has
+                 * yet to be returned.
+                 */
+                get revalidation() {
+                    return revalidation;
+                }
             },
         },
 
@@ -45,7 +66,26 @@ export function defineCachePlugin(pluginOptions: CachePluginOptions) {
                 const queryResultEntry = await cache.getQueryResult(key);
 
                 if (queryResultEntry) {
-                    return queryResultEntry.result;
+                    if (entryIsFresh(queryResultEntry)) {
+                        status = 'hit';
+                        return queryResultEntry.result;
+                    } else if (entryIsStale(queryResultEntry)) {
+                        revalidation = proceed(args).then(async (result) => {
+                            try {
+                                await cache.setQueryResult(key, {
+                                    createdAt: Date.now(),
+                                    options,
+                                    result,
+                                })
+                            }
+                            catch (err) {
+                                console.error(`Failed to cache query result: ${err}`)
+                            }
+                        });
+
+                        status = 'stale';
+                        return queryResultEntry.result;
+                    }
                 }
 
                 const result = await proceed(args);
@@ -56,6 +96,7 @@ export function defineCachePlugin(pluginOptions: CachePluginOptions) {
                     result,
                 }).catch((err) => console.error(`Failed to cache query result: ${err}`));
 
+                status = 'miss';
                 return result;
             }
 

packages/plugins/cache/src/types.ts

@@ -32,3 +32,5 @@ export type CacheQueryResultEntry = CacheEntry & {
 export type CachePluginOptions = {
     provider: CacheProvider;
 };
+
+export type CacheStatus = 'hit' | 'miss' | 'stale';

packages/plugins/cache/src/utils.ts

@@ -12,7 +12,7 @@ export function entryIsFresh(entry: CacheEntry) {
 
 export function entryIsStale(entry: CacheEntry) {
     return entry.options.swr
-        ? Date.now() <= getTotalTTL(entry)
+        ? Date.now() <= entry.createdAt + getTotalTTL(entry)
         : false;
 }
 

tests/e2e/orm/cache/memory.test.ts

@@ -292,6 +292,77 @@ describe('Cache plugin (memory)', () => {
         })).resolves.toHaveLength(2);
     });
 
+    it('respects swr', async () => {
+        const extDb = db.$use(defineCachePlugin({
+            provider: new MemoryCache(),
+        }));
+
+        const user = await extDb.user.create({
+            data: {
+                email: 'test@email.com',
+            },
+        });
+
+        await extDb.user.findFirst({
+            where: {
+                id: user.id,
+            },
+
+            cache: {
+                swr: 60,
+            },
+        });
+
+        await extDb.user.update({
+            data: {
+                name: 'newname',
+            },
+
+            where: {
+                id: user.id,
+            },
+        });
+
+        await expect(extDb.user.findFirst({
+            where: {
+                id: user.id,
+            },
+
+            cache: {
+                swr: 60,
+            },
+        })).resolves.toMatchObject({
+            name: null,
+        });
+
+        await expect(extDb.user.findFirst({
+            where: {
+                id: user.id,
+            },
+
+            cache: {
+                swr: 60,
+            },
+        })).resolves.toMatchObject({
+            name: null,
+        });
+
+        expect(extDb.$cache.status).toBe('stale');
+        await extDb.$cache.revalidation;
+
+        await expect(extDb.user.findFirst({
+            where: {
+                id: user.id,
+            },
+
+            cache: {
+                swr: 60,
+            },
+        })).resolves.toMatchObject({
+            name: 'newname',
+        });
+    });
+
     it('supports invalidating all entries', async () => {
         const extDb = db.$use(defineCachePlugin({
             provider: new MemoryCache(),