✨ Add economy system base, client logger and more!

packages/bot/src/index.ts

···
 
 // Client initialization with intents and stuff...
 const client = new VoidyClient({
-  intents: [GatewayIntentBits.Guilds],
+  intents: [GatewayIntentBits.Guilds, GatewayIntentBits.GuildMessages],
+  developers: ["423520077246103563"],
+  logChannelId: "1451025628206731459"
 });
 
 // Database URI validation and connection check

packages/bot/src/modules/core/module.ts

···
   id: "core",
   name: "Core",
   description: "Initializes the bot and registers all commands.",
-  author: "jokiller230",
+  author: "thevoid.cafe",
 
   exports: [
     {

packages/bot/src/modules/economy/commands/currency/set.ts

···
+import { MessageFlags, SlashCommandSubcommandBuilder } from "discord.js";
+import { UserCurrencyType, UserCurrency } from "../../schemas/UserCurrency";
+import type { Command } from "@voidy/framework";
+
+export default {
+  id: "currency.set",
+  devOnly: true,
+  data: new SlashCommandSubcommandBuilder()
+    .setName("set")
+    .setDescription("Override a users current balance.")
+    .addUserOption((option) =>
+      option.setName("user").setDescription("The user whose balance to override.").setRequired(true)
+    )
+    .addStringOption((option) =>
+      option
+        .setName("currency")
+        .setDescription("The currency to override.")
+        .setRequired(true)
+        .setChoices(
+          { name: "BiTS", value: UserCurrencyType.BITS },
+          { name: "Gems", value: UserCurrencyType.GEMS }
+        )
+    )
+    .addIntegerOption((option) =>
+      option
+        .setName("new_balance")
+        .setDescription("The new balance to set.")
+        .setRequired(true)
+    ),
+
+  execute: async (interaction, _client) => {
+    const { options } = interaction;
+
+    // Retrieve the requested user from our interaction options
+    const user = options.getUser("user");
+    if (!user) {
+      await interaction.reply({
+        content: "Please provide a valid user.",
+        flags: [MessageFlags.Ephemeral],
+      });
+
+      return;
+    };
+
+    // Retrieve the selected currency from our interaction options
+    const selectedCurrency = options.getString("currency");
+    if (!selectedCurrency) {
+      await interaction.reply({
+        content: "Please provide a valid currency.",
+        flags: [MessageFlags.Ephemeral],
+      });
+
+      return;
+    }
+
+    // Retrieve the new balance from our interaction options
+    const newBalance = options.getInteger("new_balance");
+    if (!newBalance) {
+      await interaction.reply({
+        content: "Please provide a valid new balance.",
+        flags: [MessageFlags.Ephemeral],
+      });
+
+      return;
+    }
+
+    // Retrieve the requested user's balance from our database
+    let userBalance = await UserCurrency.findOne({ userId: user.id, type: selectedCurrency });
+    if (!userBalance) {
+      userBalance = await UserCurrency.create({
+        userId: user.id,
+        type: selectedCurrency,
+        amount: newBalance,
+      });
+    } else {
+      userBalance.amount = newBalance;
+      await userBalance.save();
+    }
+
+    // Reply with the requested user's current balance
+    await interaction.reply({
+      content: `Balance of user \`${user.username}\` has been set to \`${userBalance.amount} ${selectedCurrency.toUpperCase()}\`.`,
+      flags: [MessageFlags.Ephemeral],
+    });
+  },
+} as Command;

packages/bot/src/modules/economy/commands/currency/view.ts

···
+import { MessageFlags, SlashCommandSubcommandBuilder } from "discord.js";
+import { UserCurrencyType, UserCurrency } from "../../schemas/UserCurrency";
+import type { Command } from "@voidy/framework";
+
+export default {
+  id: "currency.view",
+  data: new SlashCommandSubcommandBuilder()
+    .setName("view")
+    .setDescription("Retrieve a users current balance.")
+    .addUserOption((option) =>
+      option.setName("user").setDescription("The user whose balance to view.").setRequired(true)
+    )
+    .addStringOption((option) =>
+      option
+        .setName("currency")
+        .setDescription("The currency to view.")
+        .setRequired(true)
+        .setChoices(
+          { name: "BiTS", value: UserCurrencyType.BITS },
+          { name: "Gems", value: UserCurrencyType.GEMS }
+        )
+    ),
+
+  execute: async (interaction, _client) => {
+    const { options } = interaction;
+
+    // Retrieve the requested user from our interaction options
+    const user = options.getUser("user");
+    if (!user) {
+      await interaction.reply({
+        content: "Please provide a valid user.",
+        flags: [MessageFlags.Ephemeral],
+      });
+
+      return;
+    };
+
+    // Retrieve the selected currency from our interaction options
+    const selectedCurrency = options.getString("currency");
+    if (!selectedCurrency) {
+      await interaction.reply({
+        content: "Please provide a valid currency.",
+        flags: [MessageFlags.Ephemeral],
+      });
+
+      return;
+    }
+
+    // Retrieve the requested user's balance from our database
+    const userBalance = await UserCurrency.findOne({ userId: user.id, type: selectedCurrency });
+    if (!userBalance || UserCurrencyType === undefined || userBalance.amount === 0) {
+      await interaction.reply({
+        content: `The requested user hasn't earned any \`${selectedCurrency.toUpperCase()}\` yet.`,
+        flags: [MessageFlags.Ephemeral],
+      });
+
+      return;
+    }
+
+    // Reply with the requested user's current balance
+    await interaction.reply({
+      content: `User \`${user.username}\` has \`${userBalance.amount} ${selectedCurrency.toUpperCase()}\`.`,
+      flags: [MessageFlags.Ephemeral],
+    });
+  },
+} as Command;

packages/bot/src/modules/economy/events/messageCreate.ts

···
+import type { Event, VoidyClient } from "@voidy/framework";
+import { UserCurrency, UserCurrencyType } from "../schemas/UserCurrency";
+import { Events, Message } from "discord.js";
+
+export default {
+  id: "messageCreate",
+  name: Events.MessageCreate,
+  execute: async (client: VoidyClient, message: Message) => {
+    // Don't collect currencies for bots
+    if (message.author.bot) return;
+
+    // Retrieve user balance of BITS
+    let userCurrency = await UserCurrency.findOne({ userId: message.author.id, type: UserCurrencyType.BITS });
+    if (!userCurrency) {
+      userCurrency = await UserCurrency.create({ userId: message.author.id, type: UserCurrencyType.BITS });
+    }
+
+    // Increase user balance of BITS at random
+    if (Math.random() < 0.5) { // 50% chance
+      // Calculate amount of BITS to give, between 1 and 10
+      const amount = Math.floor(Math.random() * 10) + 1;
+
+      // Update user balance of BITS and commit changes
+      userCurrency.amount += amount;
+      await userCurrency.save();
+
+      // Log to logging channel
+      await client.logger.send(`User \`${message.author.tag}\` received \`${amount} BITS\``);
+    }
+  }
+} as Event;

packages/bot/src/modules/economy/module.ts

···
+import { CommandLoader, EventLoader } from "@voidy/framework";
+
+export default {
+  id: "economy",
+  name: "Economy Management Services",
+  description:
+    "Provides various resources for working with users economies and currencies, including storage, transactions, and economy-related commands.",
+  author: "thevoid.cafe",
+
+  exports: [
+    {
+      source: `${import.meta.dir}/commands`,
+      loader: CommandLoader,
+    },
+    {
+      source: `${import.meta.dir}/events`,
+      loader: EventLoader,
+    },
+  ],
+};

packages/bot/src/modules/economy/schemas/UserCurrency.ts

···
+import { Schema, model } from "mongoose";
+
+// Define valid currency types,
+// this should be the only source of truth for currency types.
+export enum UserCurrencyType {
+  BITS = "bits",
+  GEMS = "gems"
+}
+
+export const UserCurrency = model(
+  "UserCurrency",
+  new Schema({
+    userId: { type: String, required: true },
+    type: { type: String, enum: UserCurrencyType, required: true },
+    amount: { type: Number, required: true, default: 0 },
+  }),
+);

packages/bot/src/modules/toys/module.ts

···
   id: "toys",
   name: "Toys",
   description: "Provides various fun commands, e.g. coinflip, dice or simple API interactions",
+  author: "thevoid.cafe",
+
   exports: [
     {
-      src: `${import.meta.dir}/commands`,
+      source: `${import.meta.dir}/commands`,
       loader: CommandLoader,
     },
   ],

packages/bot/src/modules/user/module.ts

···
   name: "User Management Services",
   description:
     "Provides various resources for working with users, like global preferences and consent statements.",
+  author: "thevoid.cafe",
+
   exports: [
     {
-      src: `${import.meta.dir}/commands`,
+      source: `${import.meta.dir}/commands`,
       loader: CommandLoader,
     },
   ],

packages/bot/src/modules/user/schemas/UserConfig.ts

···
 export const UserConfig = model(
   "UserConfig",
   new Schema({
-    id: { type: String, required: true, primary: true },
+    userId: { type: String, required: true },
     consent: {
       type: Object,
       required: true,

packages/framework/src/core/Logger.ts

···
+import type { VoidyClient } from "./VoidyClient";
+
+export class Logger {
+  private logChannelId?: string;
+
+  constructor(private client: VoidyClient) {}
+
+  public async send(message: string) {
+    if (!this.logChannelId) return;
+
+    try {
+      const loggingChannel = this.client.channels.cache.get(this.logChannelId);
+      if (loggingChannel && loggingChannel.isSendable()) {
+        await loggingChannel.send(message);
+      }
+    } catch {}
+
+    console.log(message);
+  }
+
+  public setChannelId(id: string) {
+    this.logChannelId = id;
+  }
+}

packages/framework/src/core/VoidyClient.ts

···
   Events,
 } from "discord.js";
 import { ModuleManager, type CacheMap } from "./ModuleManager";
+import { Logger } from "./Logger";
 import type { Command } from "./types/Command";
 import type { Button } from "./types/Button";
 import type { Event } from "./types/Event";
 
 //===============================================
+//  ClientOptions Override
+//===============================================
+export interface VoidyClientOptions extends ClientOptions {
+  developers?: string[]; // List of developer user ids
+  logChannelId?: string; // ID of the channel to log events to
+}
+
+//===============================================
 //  VoidyClient Implementation
 //===============================================
 export class VoidyClient extends Client {
   public moduleManager = new ModuleManager();
+  public developers: string[] = [];
+  public logger: Logger = new Logger(this);
 
-  public constructor(options: ClientOptions) {
+  public constructor(options: VoidyClientOptions) {
     super(options);
+
+    // Set developers, if provided.
+    if (options.developers) {
+      this.developers = options.developers;
+    }
+
+    // Inject channel ID into logger, if provided.
+    if (options.logChannelId) {
+      this.logger.setChannelId(options.logChannelId);
+    }
   }
 
   /**

packages/framework/src/core/types/Command.ts

···
 //===============================================
 export interface Command extends Resource {
   data: SlashCommandBuilder | SlashCommandSubcommandBuilder | SlashCommandSubcommandGroupBuilder;
+  devOnly: boolean | null;
   execute: (interaction: ChatInputCommandInteraction, client: VoidyClient) => Promise<void>;
 }

packages/framework/src/handlers/ButtonHandler.ts

···
 import type { ButtonInteraction } from "discord.js";
-import type { Button } from "../loaders/ButtonLoader";
+import type { Button } from "../core/types/Button";
 import type { VoidyClient } from "../core/VoidyClient";
 
 export class ButtonHandler {

packages/framework/src/handlers/CommandHandler.ts

···
-import type { ChatInputCommandInteraction } from "discord.js";
-import type { Command } from "../loaders/CommandLoader";
+import { MessageFlags, type ChatInputCommandInteraction } from "discord.js";
+import type { Command } from "../core/types/Command";
 import type { VoidyClient } from "../core/VoidyClient";
 
 export class ChatInputCommandHandler {
-  public static invoke(
+  public static async invoke(
     interaction: ChatInputCommandInteraction,
     payload: Command,
     client: VoidyClient,
-  ): void {
+  ): Promise<void> {
+    if (!client.developers.includes(interaction.user.id)) {
+      await interaction.reply({
+        content: "You are not authorized to use this command.",
+        flags: [MessageFlags.Ephemeral]
+      });
+
+      return;
+    }
+
     payload.execute(interaction, client);
   }
 }