add some documentation, add timeout and itemuses tracking system

bot/commands/index.ts

@@ -20,8 +20,8 @@ export class Command {
 };
 
 import { readdir } from 'node:fs/promises';
-const commands = new Map<string, Command>;
-const basecommands = new Map<string, Command>;
+const commands = new Map<string, Command>; // This map has all command/item aliases mapped to commands/items (many-to-one)
+const basecommands = new Map<string, Command>; // This map has all command names mapped to commands (one-to-one) (no items)
 
 const files = await readdir(import.meta.dir);
 for (const file of files) {

bot/db/connection.ts

@@ -12,17 +12,32 @@ export type authRecord = {
 
 export type userRecord = {
   id: string;
-  username: string;
+  username: string; // Don't use this, Use User.username or User.displayName. This is just to make the pocketbase data easier to read.
   balance: number;
   inventory: inventory;
   lastlootbox: string;
 };
 
+export type usedItemRecord = {
+  id?: string;
+  user: string;
+  item: string;
+  created: string;
+};
+
+export type timeoutRecord = {
+  id?: string;
+  user: string;
+  target: string;
+  item: string;
+  created: string;
+};
+
 interface TypedPocketBase extends PocketBase {
   collection(idOrName: 'auth'): RecordService<authRecord>;
   collection(idOrName: 'users'): RecordService<userRecord>;
+  collection(idOrName: 'usedItems'): RecordService<usedItemRecord>;
+  collection(idOrName: 'timeouts'): RecordService<timeoutRecord>;
 };
 
-const pb = new PocketBase(pocketbaseurl) as TypedPocketBase;
-export default pb.autoCancellation(false);
-
+export default new PocketBase(pocketbaseurl).autoCancellation(false) as TypedPocketBase;

bot/db/dbTimeouts.ts

@@ -0,0 +1,12 @@
+import pocketbase from "./connection";
+import { User } from "../user";
+const pb = pocketbase.collection('timeouts');
+
+export async function createTimeoutRecord(user: User, target: User, item: string): Promise<void> {
+  try {
+    await pb.create({ user: user.id, target: target.id, item });
+  } catch (err) {
+    console.error(`Failed to create timeout record in database: user: ${user.id}, target: ${target.id}, item: ${item}`);
+    console.error(err);
+  };
+};

bot/db/dbUsedItems.ts

@@ -0,0 +1,12 @@
+import pocketbase from "./connection";
+import { User } from "../user";
+const pb = pocketbase.collection('usedItems');
+
+export async function createUsedItemRecord(user: User, item: string): Promise<void> {
+  try {
+    await pb.create({ user: user.id, item });
+  } catch (err) {
+    console.error(`Failed to create usedItem record in database: user: ${user.id}, item: ${item}`);
+    console.error(err);
+  };
+};

bot/db/dbUser.ts

@@ -6,7 +6,7 @@ const pb = pocketbase.collection('users');
 /** Use this function to both ensure existance and to retreive data */
 export async function getUserRecord(user: User): Promise<userRecord> {
   try {
-    const data = await pb.getOne<userRecord>(user.id);
+    const data = await pb.getOne(user.id);
 
     if (Object.keys(data.inventory).sort().toString() !== itemarray.sort().toString()) { // If the items in the user inventory are missing an item.
       itemarray.forEach(key => {
@@ -22,7 +22,7 @@ export async function getUserRecord(user: User): Promise<userRecord> {
 };
 
 async function createUserRecord(user: User): Promise<userRecord> {
-  const data = await pb.create<userRecord>({
+  const data = await pb.create({
     id: user.id,
     username: user.username,
     balance: 0,

bot/items/blaster.ts

@@ -1,5 +1,7 @@
 import { changeItemCount, Item } from ".";
 import { sendMessage } from "../commands";
+import { createTimeoutRecord } from "../db/dbTimeouts";
+import { createUsedItemRecord } from "../db/dbUsedItems";
 import { getUserRecord } from "../db/dbUser";
 import parseCommandArgs from "../lib/parseCommandArgs";
 import { timeout } from "../lib/timeout";
@@ -17,13 +19,16 @@ export default new Item(ITEMNAME, 'Blaster', 's',
     if (!messagequery[0]) { await sendMessage('Please specify a target'); return; };
     const target = await User.initUsername(messagequery[0].toLowerCase());
     if (!target) { await sendMessage(`${messagequery[0]} doesn't exist`); return; };
-    await getUserRecord(target);
+    await getUserRecord(target); // make sure the user record exist in the database
+
     if (await user.itemLock()) { await sendMessage('Can\'t use two items at once pepeW', msg.messageId); return; };
     await user.setLock();
     const result = await timeout(target, `You got blasted by ${user.displayName}!`, 60);
     if (result.status) await Promise.all([
       sendMessage(`GOTTEM ${target.displayName} got BLASTED by ${user.displayName} GOTTEM`),
-      changeItemCount(user, userObj, ITEMNAME)
+      changeItemCount(user, userObj, ITEMNAME),
+      createTimeoutRecord(user, target, ITEMNAME),
+      createUsedItemRecord(user, ITEMNAME)
     ]);
     else {
       switch (result.reason) {

bot/items/grenade.ts

@@ -4,6 +4,8 @@ import { timeout } from "../lib/timeout";
 import { changeItemCount, Item } from ".";
 import { User } from "../user";
 import { getUserRecord } from "../db/dbUser";
+import { createTimeoutRecord } from "../db/dbTimeouts";
+import { createUsedItemRecord } from "../db/dbUsedItems";
 
 const ITEMNAME = 'grenade';
 
@@ -17,13 +19,18 @@ export default new Item(ITEMNAME, 'Grenade', 's',
     if (targets.length === 0) { await sendMessage('No vulnerable chatters to blow up', msg.messageId); return; };
     const selection = targets[Math.floor(Math.random() * targets.length)]!;
     const target = await User.initUserId(selection.split(':')[1]!);
+
+    await getUserRecord(target!); // make sure the user record exist in the database
+
     if (await user.itemLock()) { await sendMessage('Can\'t use two items at once pepeW', msg.messageId); return; };
     await user.setLock();
     await Promise.all([
       timeout(target!, `You got hit by ${user.displayName}'s grenade!`, 60),
       redis.del(selection),
       sendMessage(`wybuh ${target?.displayName} got hit by ${user.displayName}'s grenade wybuh`),
-      changeItemCount(user, userObj, ITEMNAME)
+      changeItemCount(user, userObj, ITEMNAME),
+      createTimeoutRecord(user, target!, ITEMNAME),
+      createUsedItemRecord(user, ITEMNAME)
     ]);
     await user.clearLock();
   }