fix: cli issues

Author: twlite

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

@@ -9,7 +9,7 @@ const random = cache(
   async () => {
     return Math.random();
   },
-  { tag: 'random', ttl: 60_000 },
+  { name: 'random', ttl: 60_000 },
 );
 
 export async function run({ interaction }: SlashCommandProps) {

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

@@ -10,12 +10,22 @@ async function getUserXP(guildId: string, userId: string) {
   'use cache';
 
   const key = `xp:${guildId}:${userId}`;
-
-  cacheTag(key);
+  console.log('[getUserXP] Before database.get', {
+    key,
+    timestamp: Date.now(),
+  });
 
   const xp: number = (await database.get(key)) ?? 0;
 
-  console.log(`Cached XP: ${xp} for ${key}`);
+  console.log('[getUserXP] After database.get', {
+    key,
+    xp,
+    timestamp: Date.now(),
+  });
+
+  cacheTag(key);
+
+  console.log(`Cached XP: ${xp} for ${key} = ${xp}`);
 
   return xp;
 }

apps/test-bot/src/database/store.ts

@@ -1,28 +1,27 @@
 import { setTimeout } from 'node:timers/promises';
 
 // Simulate a random latency between 30ms to 1.5s
-const randomLatency = () => setTimeout(Math.floor(Math.random() * 1500) + 30);
+const randomLatency = () => setTimeout(Math.floor(Math.random() * 1500) + 100);
 
 class DataStore {
   private store = new Map<string, any>();
 
   async get(key: string) {
     await randomLatency();
-    return this.store.get(key);
+    const value = this.store.get(key);
+
+    return value;
   }
 
   async set(key: string, value: any) {
-    await randomLatency();
     this.store.set(key, value);
   }
 
   async delete(key: string) {
-    await randomLatency();
     this.store.delete(key);
   }
 
   async clear() {
-    await randomLatency();
     this.store.clear();
   }
 }

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

@@ -6,11 +6,11 @@ export default async function (message: Message) {
   if (message.author.bot || !message.inGuild()) return;
 
   const key = `xp:${message.guildId}:${message.author.id}`;
+
   const oldXp = (await database.get(key)) ?? 0;
   const xp = Math.floor(Math.random() * 10) + 1;
+  const newXp = oldXp + xp;
 
-  await database.set(key, oldXp + xp);
-
-  // invalidate the cache
+  await database.set(key, newXp);
   await invalidate(key);
 }

apps/test-bot/src/index.ts

@@ -1,5 +1,6 @@
 import { CommandKit } from 'commandkit';
 import { Client } from 'discord.js';
+
 process.loadEnvFile();
 
 const client = new Client({

packages/commandkit/package.json

@@ -62,4 +62,4 @@
   "engines": {
     "node": ">=22"
   }
-}
+}

packages/commandkit/spec/cache.test.ts

@@ -179,12 +179,6 @@ describe('Cache', () => {
     expect(await fn()).not.toBe(result1);
   });
 
-  test('Should throw when invalidating non-existent cache', async () => {
-    await expect(invalidate('non-existent')).rejects.toThrow(
-      'Cache key non-existent was not found',
-    );
-  });
-
   test('Should revalidate cache using tag', async () => {
     async function fn(multiplier: number) {
       'use cache';
@@ -200,12 +194,6 @@ describe('Cache', () => {
     expect(await fn(2)).toBe(fresh);
   });
 
-  test('Should throw when revalidating non-existent cache', async () => {
-    await expect(revalidate('non-existent')).rejects.toThrow(
-      'Cache key non-existent was not found',
-    );
-  });
-
   test('Should cache with multiple arguments', async () => {
     const fn = cache(async (a: number, b: string) => {
       return Math.random() + a + b;

packages/commandkit/src/app/commands/Context.ts

@@ -7,6 +7,7 @@ import {
   Interaction,
   UserContextMenuCommandInteraction,
   Client,
+  Awaitable,
 } from 'discord.js';
 import { CommandKit } from '../../CommandKit';
 import { Localization } from '../i18n/Localization';
@@ -85,6 +86,18 @@ export type CommandContextOptions<T extends CommandExecutionMode> =
             ? UserContextMenuCommandInteraction['options']
             : never;
 
+export type AnyCommandExecute<ContextType extends Context = Context> = (
+  ctx: ContextType,
+) => Awaitable<unknown>;
+
+export type SlashCommand = AnyCommandExecute<SlashCommandContext>;
+export type AutocompleteCommand = AnyCommandExecute<AutocompleteCommandContext>;
+export type MessageContextMenuCommand =
+  AnyCommandExecute<MessageContextMenuCommandContext>;
+export type UserContextMenuCommand =
+  AnyCommandExecute<UserContextMenuCommandContext>;
+export type MessageCommand = AnyCommandExecute<MessageCommandContext>;
+
 export class Context<
   ExecutionMode extends CommandExecutionMode = CommandExecutionMode,
 > {

packages/commandkit/src/cache/cache.ts

@@ -79,6 +79,15 @@ function getCacheProvider() {
  * Internal cache implementation
  * @internal
  * @private
+ * This is used directly by the compiler if the function is annotated with `"use cache"` directive.
+ * @example
+ * ```ts
+ * async function myCachedFunction() {
+ *   "use cache";
+ *   // can use cacheTag() and cacheLife() here to customize cache behavior
+ *   return await db.query('SELECT * FROM users');
+ * }
+ * ```
  */
 function useCache<R extends any[], F extends AsyncFunction<R>>(
   fn: F,
@@ -125,26 +134,29 @@ function useCache<R extends any[], F extends AsyncFunction<R>>(
 
         // Try to get cached value using effective key
         const cached = await provider.get(effectiveKey);
-        if (cached) return cached.value;
+        if (cached && cached.value != null) return cached.value;
 
         // If we reach here, we need to cache the value
         const result = await fn(...args);
 
-        // Get the final key name (might have been modified by cacheTag)
-        const finalKey = context.params.name!;
-        const ttl = context.params.ttl ?? DEFAULT_TTL;
-
-        // Store the result
-        await provider.set(finalKey, result, ttl);
-
-        // Update function store
-        fnStore.set(keyHash, {
-          key: finalKey,
-          hash: keyHash,
-          ttl,
-          original: fn,
-          memo,
-        });
+        // Only cache if result is not null/undefined
+        if (result != null) {
+          // Get the final key name (might have been modified by cacheTag)
+          const finalKey = context.params.name!;
+          const ttl = context.params.ttl ?? DEFAULT_TTL;
+
+          // Store the result
+          await provider.set(finalKey, result, ttl);
+
+          // Update function store
+          fnStore.set(keyHash, {
+            key: finalKey,
+            hash: keyHash,
+            ttl,
+            original: fn,
+            memo,
+          });
+        }
 
         return result;
       },
@@ -252,10 +264,6 @@ export async function invalidate(tag: string): Promise<void> {
     (v) => v.key === tag || v.hash === tag,
   );
 
-  // if (!entry) {
-  //   throw new Error(`Cache key ${tag} was not found.`);
-  // }
-
   if (!entry) return;
 
   await provider.delete(entry.key);
@@ -282,10 +290,6 @@ export async function revalidate<T = unknown>(
     (v) => v.key === tag || v.hash === tag,
   );
 
-  // if (!entry) {
-  //   throw new Error(`Cache key ${tag} was not found.`);
-  // }
-
   if (!entry) return undefined as T;
 
   await provider.delete(entry.key);

packages/commandkit/src/cli/build.ts

@@ -10,23 +10,55 @@ import {
   panic,
   write,
 } from './common.js';
-import ora from 'ora';
 import { commandkitPlugin } from './esbuild-plugins/plugin';
 import colors from '../utils/colors.js';
+import { createSpinner } from './utils';
+import { BuildOptions } from './types';
 
-export async function bootstrapProductionBuild(config: any) {
+export async function bootstrapProductionBuild(configPath: string) {
+  const config = await findCommandKitConfig(configPath);
+  const spinner = createSpinner('Creating optimized production build...');
+  const start = performance.now();
+
+  try {
+    await buildProject(config);
+    spinner.succeed(
+      colors.green(
+        `Build completed in ${(performance.now() - start).toFixed(2)}ms!`,
+      ),
+    );
+  } catch (e) {
+    spinner.fail('Build failed');
+    panic(e instanceof Error ? e.stack : e);
+  }
+}
+
+export async function bootstrapDevelopmentBuild(configPath: string) {
+  const config = await findCommandKitConfig(configPath);
+
+  try {
+    await buildProject({
+      ...config,
+      outDir: '.commandkit',
+      isDevelopment: true,
+    });
+  } catch (e) {
+    console.error(e instanceof Error ? e.stack : e);
+    console.error(
+      colors.red('Failed to build the project. Waiting for changes...'),
+    );
+  }
+}
+
+async function buildProject(options: BuildOptions) {
   const {
     sourcemap = false,
     minify = false,
     outDir = 'dist',
     antiCrash = true,
-    src,
     main,
     requirePolyfill: polyfillRequire,
-  } = await findCommandKitConfig(config);
-
-  const status = ora('Creating optimized production build...\n').start();
-  const start = performance.now();
+  } = options;
 
   erase(outDir);
 
@@ -38,32 +70,40 @@ export async function bootstrapProductionBuild(config: any) {
       skipNodeModulesBundle: true,
       minify,
       shims: true,
-      banner: {
-        js: '/* Optimized production build generated by CommandKit */',
-      },
+      banner: options.isDevelopment
+        ? {}
+        : {
+            js: '/* Optimized production build generated by CommandKit */',
+          },
       sourcemap,
       keepNames: true,
       outDir,
       silent: true,
-      watch: false,
+      watch: !!options.isDevelopment && !!options.watch,
       cjsInterop: true,
-      splitting: false,
-      entry: [src, '!dist', '!.commandkit', `!${outDir}`],
-      esbuildPlugins: [commandkitPlugin()],
+      splitting: true,
+      entry: ['src', '!dist', '!.commandkit', `!${outDir}`],
+      esbuildPlugins: [
+        commandkitPlugin({
+          'jsx-importsource': false,
+          'use-cache': true,
+          'use-macro': !!options.isDevelopment,
+        }),
+      ],
       jsxFactory: 'CommandKit.createElement',
       jsxFragment: 'CommandKit.Fragment',
       async onSuccess() {
-        await copyLocaleFiles(src, '.commandkit');
+        await copyLocaleFiles('src', outDir);
       },
     });
 
-    await injectShims(outDir, main, antiCrash, polyfillRequire);
-
-    status.succeed(
-      colors.green(
-        `Build completed in ${(performance.now() - start).toFixed(2)}ms!`,
-      ),
+    await injectShims(
+      outDir,
+      main,
+      !options.isDevelopment && antiCrash,
+      !!polyfillRequire,
     );
+
     write(
       colors.green(
         `\nRun ${colors.magenta(`commandkit start`)} ${colors.green(
@@ -72,9 +112,6 @@ export async function bootstrapProductionBuild(config: any) {
       ),
     );
   } catch (e) {
-    status.fail(
-      `Build failed after ${(performance.now() - start).toFixed(2)}ms!`,
-    );
     panic(e);
   }
 }