refactor: rewrite cache utilities

Author: twlite

apps/test-bot/src/commands/misc/invalidate-random.ts

@@ -0,0 +1,20 @@
+import {
+  SlashCommandProps,
+  CommandData,
+  unstable_invalidate as invalidate,
+} from 'commandkit';
+
+export const data: CommandData = {
+  name: 'invalidate-random',
+  description: 'This is a random command invalidation.',
+};
+
+export async function run({ interaction }: SlashCommandProps) {
+  await interaction.deferReply();
+
+  await invalidate('random');
+
+  return interaction.editReply({
+    content: `Random value has been invalidated.`,
+  });
+}

apps/test-bot/src/commands/misc/random.ts

@@ -0,0 +1,27 @@
+import {
+  SlashCommandProps,
+  CommandData,
+  unstable_cache as cache,
+} from 'commandkit';
+
+export const data: CommandData = {
+  name: 'random',
+  description: 'This is a random command.',
+};
+
+const random = cache(
+  async () => {
+    return Math.random();
+  },
+  { tag: 'random', ttl: 60_000 },
+);
+
+export async function run({ interaction }: SlashCommandProps) {
+  await interaction.deferReply();
+
+  const xp = await random();
+
+  return interaction.editReply({
+    content: `Random value is: ${xp}`,
+  });
+}

apps/test-bot/src/commands/misc/revalidate-random.ts

@@ -0,0 +1,20 @@
+import {
+  SlashCommandProps,
+  CommandData,
+  unstable_revalidate as revalidate,
+} from 'commandkit';
+
+export const data: CommandData = {
+  name: 'revalidate-random',
+  description: 'This is a random command invalidation.',
+};
+
+export async function run({ interaction }: SlashCommandProps) {
+  await interaction.deferReply();
+
+  const revalidated = await revalidate<number>('random');
+
+  return interaction.editReply({
+    content: `Random value has been revalidated. The new value will be ${revalidated}`,
+  });
+}

apps/test-bot/src/commands/misc/xp.ts

@@ -13,9 +13,13 @@ export const data: CommandData = {
 async function getUserXP(guildId: string, userId: string) {
   'use cache';
 
-  cacheTag(`xp:${guildId}:${userId}`);
+  const key = `xp:${guildId}:${userId}`;
 
-  const xp: number = (await database.get(`${guildId}:${userId}`)) ?? 0;
+  cacheTag(key);
+
+  const xp: number = (await database.get(key)) ?? 0;
+
+  console.log(`Cached XP: ${xp} for ${key}`);
 
   return xp;
 }

apps/test-bot/src/events/messageCreate/give-xp.ts

@@ -1,5 +1,5 @@
 import type { Message } from 'discord.js';
-import { unstable_revalidate as revalidate } from 'commandkit';
+import { unstable_invalidate as invalidate } from 'commandkit';
 import { database } from '../../database/store';
 
 export default async function (message: Message) {
@@ -9,8 +9,9 @@ export default async function (message: Message) {
     (await database.get(`${message.guildId}:${message.author.id}`)) ?? 0;
   const xp = Math.floor(Math.random() * 10) + 1;
 
-  await database.set(`${message.guildId}:${message.author.id}`, oldXp + xp);
+  const key = `xp:${message.guildId}:${message.author.id}`;
+  await database.set(key, oldXp + xp);
 
-  // revalidate the cache
-  await revalidate(`xp:${message.guildId}:${message.author.id}`);
+  // invalidate the cache
+  await invalidate(key);
 }

packages/commandkit/src/cache/CacheProvider.ts

@@ -1,12 +1,11 @@
-export interface CacheEntry {
-  key: string;
-  value: any;
+export interface CacheEntry<T = unknown> {
+  value: T;
   ttl?: number;
 }
 
 export abstract class CacheProvider {
-  abstract get(key: string): Promise<CacheEntry | undefined>;
-  abstract set(key: string, value: any, ttl?: number): Promise<void>;
+  abstract get<T>(key: string): Promise<CacheEntry<T> | undefined>;
+  abstract set<T>(key: string, value: T, ttl?: number): Promise<void>;
   abstract exists(key: string): Promise<boolean>;
   abstract delete(key: string): Promise<void>;
   abstract clear(): Promise<void>;

packages/commandkit/src/cache/MemoryCache.ts

@@ -3,7 +3,7 @@ import { CacheEntry, CacheProvider } from './CacheProvider';
 export class MemoryCache extends CacheProvider {
   #cache = new Map<string, CacheEntry>();
 
-  public async get<T>(key: string): Promise<T | undefined> {
+  public async get<T>(key: string): Promise<CacheEntry<T> | undefined> {
     const entry = this.#cache.get(key);
 
     if (!entry) {
@@ -15,15 +15,16 @@ export class MemoryCache extends CacheProvider {
       return undefined;
     }
 
-    return entry.value;
+    return entry as CacheEntry<T>;
   }
 
   public async set<T>(key: string, value: T, ttl?: number): Promise<void> {
-    this.#cache.set(key, {
-      key,
+    const entry: CacheEntry<T> = {
       value,
       ttl: ttl != null ? Date.now() + ttl : undefined,
-    });
+    };
+
+    this.#cache.set(key, entry);
   }
 
   public async exists(key: string): Promise<boolean> {