Simplify code.

Author: sanny-io

packages/cache/src/plugin.ts

@@ -1,5 +1,5 @@
 import { definePlugin } from '@zenstackhq/orm'
-import stableStringify from 'stable-hash'
+import { stableHash } from 'stable-hash'
 import murmurhash from 'murmurhash'
 import { cacheEnvelopeSchema } from './schemas'
 import type {
@@ -58,7 +58,7 @@ export function defineCachePlugin(pluginOptions: CachePluginOptions) {
 
     onQuery: async ({ args, model, operation, proceed }) => {
       if (args && 'cache' in args) {
-        const json = stableStringify({
+        const json = stableHash({
           args,
           model,
           operation,

packages/cache/src/providers/redis.ts

@@ -2,61 +2,11 @@ import type { CacheInvalidationOptions, CacheProvider, CacheEntry } from '../typ
 import { Redis } from 'ioredis'
 import { getTotalTtl } from '../utils'
 
-interface ZenStackRedisCommands {
-  invalidate: (options: string) => Promise<void>
-  invalidateAll: () => Promise<void>
-}
-
-declare module 'ioredis' {
-  interface Redis extends ZenStackRedisCommands {}
-}
-
 export class RedisCacheProvider implements CacheProvider {
   private readonly redis: Redis
 
   constructor(options: RedisCacheProviderOptions) {
-    this.redis = new Redis(options.url, {
-      scripts: {
-        invalidate: {
-          numberOfKeys: 0,
-          lua: `
-            local options = cjson.decode(ARGV[1])
-            local keysToDelete = {}
-
-            if (options.tags) then
-                for _, tag in ipairs(options.tags) do
-                    local formattedTag = 'zenstack:tag:' .. tag
-                    local keys = redis.call('SMEMBERS', formattedTag)
-
-                    for _, key in ipairs(keys) do
-                      keysToDelete[#keysToDelete + 1] = key
-                    end
-
-                    redis.call('DEL', formattedTag)
-                end
-            end
-
-            if (#keysToDelete > 0) then
-              redis.call('DEL', unpack(keysToDelete))
-            end
-          `,
-        },
-
-        invalidateAll: {
-          numberOfKeys: 0,
-          lua: `
-            local keys = redis.call('SMEMBERS', 'zenstack:key')
-
-            for i = 1, #keys do
-                local key = keys[i]
-                redis.call('DEL', key)
-            end
-
-            redis.call('DEL', 'zenstack:key')
-          `,
-        },
-      },
-    })
+    this.redis = new Redis(options.url)
   }
 
   async get(key: string) {
@@ -74,7 +24,6 @@ export class RedisCacheProvider implements CacheProvider {
     const formattedKey = formatQueryKey(key)
 
     multi.set(formattedKey, JSON.stringify(entry))
-    multi.sadd('zenstack:key', formattedKey)
 
     const totalTtl = getTotalTtl(entry)
 
@@ -87,19 +36,50 @@ export class RedisCacheProvider implements CacheProvider {
         const formattedTagKey = formatTagKey(tag)
 
         multi.sadd(formattedTagKey, formattedKey)
-        multi.sadd('zenstack:key', formattedTagKey)
+
+        if (totalTtl > 0) {
+          multi.expire(formattedTagKey, totalTtl, 'GT')
+          multi.expire(formattedTagKey, totalTtl, 'NX')
+        }
       }
     }
 
     await multi.exec()
   }
 
   async invalidate(options: CacheInvalidationOptions) {
-    await this.redis.invalidate(JSON.stringify(options))
+    if (options.tags && options.tags.length > 0) {
+      await Promise.all(options.tags.map(tag => {
+        return new Promise((resolve, reject) => {
+          const stream = this.redis.sscanStream(formatTagKey(tag), {
+            count: 100,
+          })
+
+          stream.on('data', async (keys: string[]) => {
+            await this.redis.del(...keys)
+          })
+
+          stream.on('error', reject)
+          stream.on('end', resolve)
+        })
+      }))
+    }
   }
 
   async invalidateAll() {
-    await this.redis.invalidateAll()
+    await new Promise((resolve, reject) => {
+      const stream = this.redis.scanStream({
+        count: 100,
+        match: 'zenstack:cache:*',
+      })
+
+      stream.on('data', async keys => {
+        await this.redis.del(...keys)
+      })
+
+      stream.on('error', reject)
+      stream.on('end', resolve)
+    })
   }
 }
 
@@ -108,9 +88,9 @@ export type RedisCacheProviderOptions = {
 }
 
 function formatQueryKey(key: string) {
-  return `zenstack:query:${key}`
+  return `zenstack:cache:query:${key}`
 }
 
 function formatTagKey(key: string) {
-  return `zenstack:tag:${key}`
-}
+  return `zenstack:cache:tag:${key}`
+}