Cleanup.

sanny-io · sanny-io · commit efbf09ebfcdf · 2026-01-21T03:01:43.000Z
diff --git a/packages/plugins/cache/src/plugin.ts b/packages/plugins/cache/src/plugin.ts
@@ -8,7 +8,7 @@ import { entryIsFresh, entryIsStale } from './utils'
 
 export function defineCachePlugin(pluginOptions: CachePluginOptions) {
     let status: CacheStatus | null = null;
-    let revalidation: Promise<void> | null = null;
+    let revalidation: Promise<unknown> | null = null;
 
     return definePlugin({
         id: 'cache',
@@ -63,7 +63,7 @@ export function defineCachePlugin(pluginOptions: CachePluginOptions) {
                 const cache = pluginOptions.provider;
                 const options = (args as CacheEnvelope).cache!;
                 const key = murmurhash.v3(json).toString();
-                const queryResultEntry = await cache.getQueryResult(key);
+                const queryResultEntry = await cache.get(key);
 
                 if (queryResultEntry) {
                     if (entryIsFresh(queryResultEntry)) {
@@ -72,14 +72,17 @@ export function defineCachePlugin(pluginOptions: CachePluginOptions) {
                     } else if (entryIsStale(queryResultEntry)) {
                         revalidation = proceed(args).then(async (result) => {
                             try {
-                                await cache.setQueryResult(key, {
+                                await cache.set(key, {
                                     createdAt: Date.now(),
                                     options,
                                     result,
-                                })
+                                });
+
+                                return result;
                             }
                             catch (err) {
-                                console.error(`Failed to cache query result: ${err}`)
+                                console.error(`Failed to cache query result: ${err}`);
+                                return null;
                             }
                         });
 
@@ -90,7 +93,7 @@ export function defineCachePlugin(pluginOptions: CachePluginOptions) {
 
                 const result = await proceed(args);
 
-                cache.setQueryResult(key, {
+                cache.set(key, {
                     createdAt: Date.now(),
                     options,
                     result,
diff --git a/packages/plugins/cache/src/providers/memory.ts b/packages/plugins/cache/src/providers/memory.ts
@@ -1,12 +1,12 @@
-import type { CacheInvalidationOptions, CacheProvider, CacheQueryResultEntry } from '../types';
+import type { CacheInvalidationOptions, CacheProvider, CacheEntry } from '../types';
 import { entryIsExpired } from '../utils';
 
-export class MemoryCache implements CacheProvider {
-    private readonly queryResultStore: Map<string, CacheQueryResultEntry>;
+export class MemoryCacheProvider implements CacheProvider {
+    private readonly entryStore: Map<string, CacheEntry>;
     private readonly tagStore: Map<string, Set<string>>;
 
     constructor(private readonly options?: MemoryCacheOptions) {
-        this.queryResultStore = new Map<string, CacheQueryResultEntry>();
+        this.entryStore = new Map<string, CacheEntry>();
         this.tagStore = new Map<string, Set<string>>;
 
         setInterval(() => {
@@ -15,42 +15,42 @@ export class MemoryCache implements CacheProvider {
     }
 
     private checkExpiration() {
-        for (const [key, entry] of this.queryResultStore.entries()) {
+        for (const [key, entry] of this.entryStore) {
             if (entryIsExpired(entry)) {
-                this.queryResultStore.delete(key);
+                this.entryStore.delete(key);
             }
         }
 
-        for (const [tag, queryKeys] of this.tagStore.entries()) {
-            for (const queryKey of queryKeys) {
-                if (!this.queryResultStore.has(queryKey)) {
-                    queryKeys.delete(queryKey);
+        for (const [tag, keys] of this.tagStore) {
+            for (const key of keys) {
+                if (!this.entryStore.has(key)) {
+                    keys.delete(key);
                 }
             }
 
-            if (queryKeys.size === 0) {
+            if (keys.size === 0) {
                 this.tagStore.delete(tag);
             }
         }
     }
 
-    getQueryResult(key: string) {
-        return Promise.resolve(this.queryResultStore.get(key));
+    get(key: string) {
+        return Promise.resolve(this.entryStore.get(key));
     }
 
-    setQueryResult(key: string, entry: CacheQueryResultEntry) {
-        this.queryResultStore.set(key, entry);
+    set(key: string, entry: CacheEntry) {
+        this.entryStore.set(key, entry);
 
         if (entry.options.tags) {
             for (const tag of entry.options.tags) {
-                let queryKeys = this.tagStore.get(tag);
+                let keys = this.tagStore.get(tag);
 
-                if (!queryKeys) {
-                    queryKeys = new Set<string>();
-                    this.tagStore.set(tag, queryKeys);
+                if (!keys) {
+                    keys = new Set<string>();
+                    this.tagStore.set(tag, keys);
                 }
 
-                queryKeys.add(key);
+                keys.add(key);
             }
         }
 
@@ -60,11 +60,11 @@ export class MemoryCache implements CacheProvider {
     invalidate(options: CacheInvalidationOptions) {
         if (options.tags) {
             for (const tag of options.tags) {
-                const queryKeys = this.tagStore.get(tag);
+                const keys = this.tagStore.get(tag);
 
-                if (queryKeys) {
-                    for (const queryKey of queryKeys) {
-                        this.queryResultStore.delete(queryKey);
+                if (keys) {
+                    for (const key of keys) {
+                        this.entryStore.delete(key);
                     }
                 }
             }
@@ -74,7 +74,7 @@ export class MemoryCache implements CacheProvider {
     }
 
     invalidateAll() {
-        this.queryResultStore.clear();
+        this.entryStore.clear();
         this.tagStore.clear();
         return Promise.resolve();
     }
diff --git a/packages/plugins/cache/src/types.ts b/packages/plugins/cache/src/types.ts
@@ -1,13 +1,12 @@
-import type { AllReadOperations } from '@zenstackhq/orm';
 import type z from 'zod';
 import type { cacheEnvelopeSchema, cacheOptionsSchema } from './schemas';
 
 export type CacheEnvelope = z.infer<typeof cacheEnvelopeSchema>;
 export type CacheOptions = z.infer<typeof cacheOptionsSchema>;
 
 export interface CacheProvider {
-    getQueryResult: (key: string) => Promise<CacheQueryResultEntry | undefined>;
-    setQueryResult: (key: string, entry: CacheQueryResultEntry) => Promise<void>;
+    get: (key: string) => Promise<CacheEntry | undefined>;
+    set: (key: string, entry: CacheEntry) => Promise<void>;
     invalidate: (options: CacheInvalidationOptions) => Promise<void>;
     invalidateAll: () => Promise<void>;
 };
@@ -16,16 +15,20 @@ export type CacheInvalidationOptions = {
     tags?: string[];
 };
 
-export type CachePluginQueryOptions = {
-    [Op in AllReadOperations]: CacheEnvelope;
-};
-
 export type CacheEntry = {
+    /**
+     * In unix epoch milliseconds.
+     */
     createdAt: number;
+
+    /**
+     * The caching options that were passed to the query.
+     */
     options: CacheOptions;
-}
 
-export type CacheQueryResultEntry = CacheEntry & {
+    /**
+     * The result of executing the query.
+     */
     result: unknown;
 };
 
diff --git a/tests/e2e/orm/cache/memory.test.ts b/tests/e2e/orm/cache/memory.test.ts
@@ -2,7 +2,7 @@ import { type ClientContract } from '@zenstackhq/orm';
 import { createTestClient } from '@zenstackhq/testtools';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { defineCachePlugin } from '@zenstackhq/plugin-cache';
-import { MemoryCache } from '@zenstackhq/plugin-cache/providers/memory';
+import { MemoryCacheProvider } from '@zenstackhq/plugin-cache/providers/memory';
 import { schema } from '../schemas/basic';
 
 describe('Cache plugin (memory)', () => {
@@ -20,7 +20,7 @@ describe('Cache plugin (memory)', () => {
 
     it('respects ttl', async () => {
         const extDb = db.$use(defineCachePlugin({
-            provider: new MemoryCache(),
+            provider: new MemoryCacheProvider(),
         }));
 
         const user = await extDb.user.create({
@@ -294,7 +294,7 @@ describe('Cache plugin (memory)', () => {
 
     it('respects swr', async () => {
         const extDb = db.$use(defineCachePlugin({
-            provider: new MemoryCache(),
+            provider: new MemoryCacheProvider(),
         }));
 
         const user = await extDb.user.create({
@@ -353,7 +353,7 @@ describe('Cache plugin (memory)', () => {
 
     it('respects ttl and swr simultaneously', async () => {
         const extDb = db.$use(defineCachePlugin({
-            provider: new MemoryCache(),
+            provider: new MemoryCacheProvider(),
         }));
 
         const user = await extDb.user.create({
@@ -431,7 +431,7 @@ describe('Cache plugin (memory)', () => {
 
     it('supports invalidating all entries', async () => {
         const extDb = db.$use(defineCachePlugin({
-            provider: new MemoryCache(),
+            provider: new MemoryCacheProvider(),
         }));
 
         const user = await extDb.user.create({
@@ -617,7 +617,7 @@ describe('Cache plugin (memory)', () => {
 
     it('supports invalidating by tags', async () => {
         const extDb = db.$use(defineCachePlugin({
-            provider: new MemoryCache(),
+            provider: new MemoryCacheProvider(),
         }));
 
         const user1 = await extDb.user.create({
@@ -870,7 +870,7 @@ describe('Cache plugin (memory)', () => {
 
     it('handles edge cases', async () => {
         const extDb = db.$use(defineCachePlugin({
-            provider: new MemoryCache(),
+            provider: new MemoryCacheProvider(),
         }));
 
         await expect(extDb.user.findMany({

Original file line number	Diff line number	Diff line change
`@@ -1,12 +1,12 @@`
`1`		`-import type { CacheInvalidationOptions, CacheProvider, CacheQueryResultEntry } from '../types';`
	`1`	`+import type { CacheInvalidationOptions, CacheProvider, CacheEntry } from '../types';`
`2`	`2`	`import { entryIsExpired } from '../utils';`
`3`	`3`
`4`		`-export class MemoryCache implements CacheProvider {`
`5`		`- private readonly queryResultStore: Map<string, CacheQueryResultEntry>;`
	`4`	`+export class MemoryCacheProvider implements CacheProvider {`
	`5`	`+ private readonly entryStore: Map<string, CacheEntry>;`
`6`	`6`	`private readonly tagStore: Map<string, Set<string>>;`
`7`	`7`
`8`	`8`	`constructor(private readonly options?: MemoryCacheOptions) {`
`9`		`- this.queryResultStore = new Map<string, CacheQueryResultEntry>();`
	`9`	`+ this.entryStore = new Map<string, CacheEntry>();`
`10`	`10`	`this.tagStore = new Map<string, Set<string>>;`
`11`	`11`
`12`	`12`	`setInterval(() => {`
`@@ -15,42 +15,42 @@ export class MemoryCache implements CacheProvider {`
`15`	`15`	`}`
`16`	`16`
`17`	`17`	`private checkExpiration() {`
`18`		`- for (const [key, entry] of this.queryResultStore.entries()) {`
	`18`	`+ for (const [key, entry] of this.entryStore) {`
`19`	`19`	`if (entryIsExpired(entry)) {`
`20`		`- this.queryResultStore.delete(key);`
	`20`	`+ this.entryStore.delete(key);`
`21`	`21`	`}`
`22`	`22`	`}`
`23`	`23`
`24`		`- for (const [tag, queryKeys] of this.tagStore.entries()) {`
`25`		`- for (const queryKey of queryKeys) {`
`26`		`- if (!this.queryResultStore.has(queryKey)) {`
`27`		`- queryKeys.delete(queryKey);`
	`24`	`+ for (const [tag, keys] of this.tagStore) {`
	`25`	`+ for (const key of keys) {`
	`26`	`+ if (!this.entryStore.has(key)) {`
	`27`	`+ keys.delete(key);`
`28`	`28`	`}`
`29`	`29`	`}`
`30`	`30`
`31`		`- if (queryKeys.size === 0) {`
	`31`	`+ if (keys.size === 0) {`
`32`	`32`	`this.tagStore.delete(tag);`
`33`	`33`	`}`
`34`	`34`	`}`
`35`	`35`	`}`
`36`	`36`
`37`		`- getQueryResult(key: string) {`
`38`		`- return Promise.resolve(this.queryResultStore.get(key));`
	`37`	`+ get(key: string) {`
	`38`	`+ return Promise.resolve(this.entryStore.get(key));`
`39`	`39`	`}`
`40`	`40`
`41`		`- setQueryResult(key: string, entry: CacheQueryResultEntry) {`
`42`		`- this.queryResultStore.set(key, entry);`
	`41`	`+ set(key: string, entry: CacheEntry) {`
	`42`	`+ this.entryStore.set(key, entry);`
`43`	`43`
`44`	`44`	`if (entry.options.tags) {`
`45`	`45`	`for (const tag of entry.options.tags) {`
`46`		`- let queryKeys = this.tagStore.get(tag);`
	`46`	`+ let keys = this.tagStore.get(tag);`
`47`	`47`
`48`		`- if (!queryKeys) {`
`49`		`- queryKeys = new Set<string>();`
`50`		`- this.tagStore.set(tag, queryKeys);`
	`48`	`+ if (!keys) {`
	`49`	`+ keys = new Set<string>();`
	`50`	`+ this.tagStore.set(tag, keys);`
`51`	`51`	`}`
`52`	`52`
`53`		`- queryKeys.add(key);`
	`53`	`+ keys.add(key);`
`54`	`54`	`}`
`55`	`55`	`}`
`56`	`56`
`@@ -60,11 +60,11 @@ export class MemoryCache implements CacheProvider {`
`60`	`60`	`invalidate(options: CacheInvalidationOptions) {`
`61`	`61`	`if (options.tags) {`
`62`	`62`	`for (const tag of options.tags) {`
`63`		`- const queryKeys = this.tagStore.get(tag);`
	`63`	`+ const keys = this.tagStore.get(tag);`
`64`	`64`
`65`		`- if (queryKeys) {`
`66`		`- for (const queryKey of queryKeys) {`
`67`		`- this.queryResultStore.delete(queryKey);`
	`65`	`+ if (keys) {`
	`66`	`+ for (const key of keys) {`
	`67`	`+ this.entryStore.delete(key);`
`68`	`68`	`}`
`69`	`69`	`}`
`70`	`70`	`}`
`@@ -74,7 +74,7 @@ export class MemoryCache implements CacheProvider {`
`74`	`74`	`}`
`75`	`75`
`76`	`76`	`invalidateAll() {`
`77`		`- this.queryResultStore.clear();`
	`77`	`+ this.entryStore.clear();`
`78`	`78`	`this.tagStore.clear();`
`79`	`79`	`return Promise.resolve();`
`80`	`80`	`}`