fix: types package issue on fresh build

Author: twlite

apps/test-bot/src/app.ts

@@ -1,4 +1,5 @@
 import { Client } from 'discord.js';
+import { Logger, onApplicationBootstrap } from 'commandkit';
 
 const client = new Client({
   intents: [
@@ -10,4 +11,16 @@ const client = new Client({
   ],
 });
 
+onApplicationBootstrap((commandkit) => {
+  Logger.log('Application bootstrapped successfully!');
+  commandkit.setPrefixResolver((message) => {
+    return [
+      `<@${message.client.user.id}>`,
+      `<@!${message.client.user.id}>`,
+      '!',
+      '?',
+    ];
+  });
+});
+
 export default client;

apps/test-bot/src/app/commands/(developer)/server.ts

@@ -8,7 +8,7 @@ import {
 export const command: CommandData = {
   name: 'server',
   description: 'server command',
-  guilds: [process.env.DEV_GUILD_ID],
+  guilds: [process.env.DEV_GUILD_ID!],
 };
 
 export const chatInput: SlashCommand = async (ctx) => {

packages/commandkit/src/CommandKit.ts

@@ -20,6 +20,8 @@ import { CommandKitEventsChannel } from './events/CommandKitEventsChannel';
 import { isRuntimePlugin } from './plugins';
 import { generateTypesPackage } from './utils/types-package';
 import { Logger } from './logger/Logger';
+import { GenericFunction } from './context/async-context';
+import { AsyncFunction } from './cache';
 
 export interface CommandKitConfiguration {
   defaultLocale: Locale;
@@ -29,6 +31,49 @@ export interface CommandKitConfiguration {
 // @ts-ignore
 export let commandkit: CommandKit;
 
+export type BootstrapFunction =
+  | GenericFunction<[CommandKit]>
+  | AsyncFunction<[CommandKit]>;
+
+const bootstrapHooks = new Set<BootstrapFunction>();
+const onApplicationBootstrapHooks = new Set<BootstrapFunction>();
+
+/**
+ * Registers a bootstrap hook that will be called when the CommandKit instance is created.
+ * This is useful for plugins that need to run some code after the CommandKit instance is fully initialized.
+ * Note that not all commandkit dependiencs are available at this point. It is recommended to use the `onApplicationBootstrap` hook instead,
+ * if you need access to the commandkit dependencies.
+ * @param fn The bootstrap function to register.
+ * @example ```ts
+ * import { onBootstrap } from 'commandkit';
+ *
+ * onBootstrap(async (commandkit) => {
+ *   // Do something with the commandkit instance
+ * })
+ * ```
+ */
+export function onBootstrap<F extends BootstrapFunction>(fn: F): void {
+  bootstrapHooks.add(fn);
+}
+
+/**
+ * Registers a bootstrap hook that will be called when the CommandKit instance is created.
+ * This is useful for plugins that need to run some code after the CommandKit instance is fully initialized.
+ * @param fn The bootstrap function to register.
+ * @example ```ts
+ * import { onApplicationBootstrap } from 'commandkit';
+ *
+ * onApplicationBootstrap(async (commandkit) => {
+ *   // Do something with the commandkit instance
+ * })
+ * ```
+ */
+export function onApplicationBootstrap<F extends BootstrapFunction>(
+  fn: F,
+): void {
+  onApplicationBootstrapHooks.add(fn);
+}
+
 export class CommandKit extends EventEmitter {
   #started = false;
   public eventInterceptor!: EventInterceptor;
@@ -90,6 +135,37 @@ export class CommandKit extends EventEmitter {
 
     // @ts-ignore
     commandkit = CommandKit.instance;
+
+    this.#bootstrapHooks();
+  }
+
+  async #bootstrapHooks() {
+    for (const hook of bootstrapHooks) {
+      try {
+        await hook(this);
+      } catch (e) {
+        Logger.error('Error while executing bootstrap hook: ', e);
+      } finally {
+        bootstrapHooks.delete(hook);
+      }
+    }
+
+    // force clear just in case we missed something
+    bootstrapHooks.clear();
+  }
+
+  async #applicationBootstrapHooks() {
+    for (const hook of onApplicationBootstrapHooks) {
+      try {
+        await hook(this);
+      } catch (e) {
+        Logger.error('Error while executing application bootstrap hook: ', e);
+      } finally {
+        onApplicationBootstrapHooks.delete(hook);
+      }
+    }
+    // force clear just in case we missed something
+    onApplicationBootstrapHooks.clear();
   }
 
   /**
@@ -151,6 +227,8 @@ export class CommandKit extends EventEmitter {
     }
 
     this.#started = true;
+
+    await this.#applicationBootstrapHooks();
   }
 
   /**

packages/commandkit/src/cli/common.ts

@@ -4,6 +4,7 @@ import fs from 'node:fs';
 import colors from '../utils/colors';
 import { ResolvedCommandKitConfig } from '../config/utils';
 import { generateTypesPackage } from '../utils/types-package';
+import { execSync } from 'node:child_process';
 
 let ts: typeof import('typescript') | undefined;
 
@@ -42,12 +43,63 @@ async function ensureTypeScript(target: string) {
   return true;
 }
 
+let packageManager: string;
+
+function detectPackageManager() {
+  if (packageManager) return packageManager;
+
+  const lockfiles = {
+    'yarn.lock': 'yarn',
+    'pnpm-lock.yaml': 'pnpm',
+    'package-lock.json': 'npm',
+    'bun.lock': 'bun',
+    'bun.lockb': 'bun',
+  };
+
+  for (const [lockfile, manager] of Object.entries(lockfiles)) {
+    if (fs.existsSync(join(process.cwd(), lockfile))) {
+      packageManager = manager;
+      break;
+    }
+  }
+
+  if (!packageManager) {
+    packageManager = 'npm';
+  }
+
+  return packageManager;
+}
+
 export async function loadTypeScript(e?: string) {
   if (ts) return ts;
 
   try {
     ts = await import('typescript');
-  } catch {
+  } catch (e) {
+    if (e instanceof Error && 'code' in e && e.code === 'MODULE_NOT_FOUND') {
+      try {
+        const packageManager = detectPackageManager();
+
+        execSync(`${packageManager} add typescript`, {
+          stdio: 'inherit',
+          cwd: process.cwd(),
+        });
+
+        console.log(
+          colors.cyan(
+            `TypeScript has been installed automatically, restarting...`,
+          ),
+        );
+
+        ts = await import('typescript');
+
+        return ts;
+      } catch {
+        panic(
+          'TypeScript is not installed and could not be installed automatically. Please install it manually.',
+        );
+      }
+    }
     panic(e || 'TypeScript must be installed to use TypeScript config files.');
   }
 

packages/commandkit/src/cli/init.ts

@@ -1,6 +1,7 @@
 import { existsSync } from 'node:fs';
 import { mkdir } from 'node:fs/promises';
 import { join } from 'node:path';
+import { generateTypesPackage } from '../utils/types-package';
 
 /**
  * Creates a command line interface for CommandKit.
@@ -84,11 +85,12 @@ export async function bootstrapCommandkitCLI(
       }
     });
 
-  await program.parseAsync(argv, options);
-
   const types = join(process.cwd(), 'node_modules', 'commandkit-types');
 
   if (!existsSync(types)) {
     await mkdir(types, { recursive: true }).catch(() => {});
+    await generateTypesPackage(true).catch(() => {});
   }
+
+  await program.parseAsync(argv, options);
 }

packages/commandkit/src/utils/types-package.ts

@@ -3,9 +3,9 @@ import { join } from 'node:path';
 import { COMMANDKIT_IS_DEV } from './constants';
 import { existsSync } from 'node:fs';
 
-export async function generateTypesPackage() {
+export async function generateTypesPackage(force = false) {
   const location = join(process.cwd(), 'node_modules', 'commandkit-types');
-  if (!COMMANDKIT_IS_DEV) return location;
+  if (!COMMANDKIT_IS_DEV && !force) return location;
   const packageJSON = join(location, 'package.json');
   const index = join(location, 'index.js');
   const types = join(location, 'index.d.ts');

packages/redis/src/index.ts

@@ -18,7 +18,7 @@ export type DeserializeFunction = (value: string) => Awaitable<any>;
  * });
  */
 export class RedisCache extends CacheProvider {
-  protected redis: Redis;
+  public redis: Redis;
 
   /**
    * Serialize function used to serialize values before storing them in the cache.