DB updates

mdoryammilwalrus · mdoryammilwalrus · commit f111ad0505d6 · 2023-11-18T03:00:05.000Z
diff --git a/.replit b/.replit
@@ -1,4 +1,4 @@
-run = ["yarn", "start"]
+run = ["./node_modules/.bin/ts-node", "--esm", "index.ts"]
 
 [nix]
 channel = "stable-23_05"
diff --git a/commands/add.ts b/commands/add.ts
@@ -43,7 +43,7 @@ export async function run(client: any, interaction: ChatInputCommandInteraction)
   try {
     const link: string = interaction.options.getString("link", true);
     const doc = await guildModel.findOne({
-      GuildId: interaction.guild?.id
+      GuildId: interaction.guild!.id
     });
     if(!doc) return interaction.reply({
       content: ClientMessages.ERR_SERVER_NOT_FOUND_ADMIN,
@@ -94,7 +94,7 @@ export async function run(client: any, interaction: ChatInputCommandInteraction)
 }
 
 export async function autocomplete(client: any, interaction: AutocompleteInteraction) {
-  const doc = await guildModel.findOne({ GuildId: interaction.guild?.id });
+  const doc = await guildModel.findOne({ GuildId: interaction.guild!.id });
   if(!doc) return interaction.respond([]);
   const input = interaction.options.getFocused(true);
   var data: string[] = [];
diff --git a/commands/category.ts b/commands/category.ts
@@ -36,7 +36,7 @@ export async function run(client: any, interaction: ChatInputCommandInteraction)
   try {
     const category = interaction.options.getString("category", true);
     const doc = await guildModel.findOne({
-      GuildId: interaction.guild?.id
+      GuildId: interaction.guild!.id
     });
     if (!doc) return interaction.reply({
       content: ClientMessages.ERR_SERVER_NOT_FOUND_ADMIN,
@@ -71,7 +71,7 @@ export async function run(client: any, interaction: ChatInputCommandInteraction)
 }
 
 export async function autocomplete(client: any, interaction: AutocompleteInteraction) {
-  const doc = await guildModel.findOne({ GuildId: interaction.guild?.id });
+  const doc = await guildModel.findOne({ GuildId: interaction.guild!.id });
   if (!doc) return interaction.respond([]);
   const input: string = interaction.options.getFocused();
   const data: string[] = doc.types.filter((type) => type.startsWith(input));
diff --git a/commands/dm.ts b/commands/dm.ts
@@ -18,9 +18,8 @@ export async function run(client: any, interaction: ChatInputCommandInteraction)
   const doc = await guildModel.findOne({ GuildId });
   if (!doc) return interaction.reply({ content: ClientMessages.ERR_SERVER_NOT_FOUND_ADMIN, ephemeral: true });
   const enable = interaction.options.getBoolean("enabled", true);
-  const members: any = interaction.guild?.members.cache;
 
-  if (members.size < 100 && !doc.isPremium) return interaction.reply({ content: `DM mode is a premium feature for servers with more then 100 members. ${ClientMessages.ERR_NEED_PREMIUM}`, ephemeral: true });
+  if (interaction.guild!.members.cache.size < 100 && !doc.isPremium) return interaction.reply({ content: `DM mode is a premium feature for servers with more then 100 members. ${ClientMessages.ERR_NEED_PREMIUM}`, ephemeral: true });
   doc.dmMode = enable;
   doc.save();
   interaction.reply({ content: `DM mode has been ${enable ? "enabled" : "disabled"}`, ephemeral: true });
diff --git a/commands/get-started.ts b/commands/get-started.ts
@@ -8,17 +8,15 @@ export const data = new SlashCommandBuilder()
   .setDMPermission(false);
 
 export async function run(client: any, interaction: ChatInputCommandInteraction) {
-    const model = await guildModel.findOne({ GuildId: interaction.guild?.id });
+    const model = await guildModel.findOne({ GuildId: interaction.guild!.id });
     if(model) return interaction.reply({ content: "You have already set up Link Master!", ephemeral: true });
     await interaction.deferReply();
 
     const newData = new guildModel({
-        GuildId: interaction.guild?.id,
+        GuildId: interaction.guild!.id,
         isPremium: false,
         dmMode: false,
-        limit: 3,
-        types: [],
-        links: [],
+        limit: 3
     });
     await newData.save();
     interaction.editReply("Set up! Thank you for using Link Master");
diff --git a/commands/help.ts b/commands/help.ts
@@ -11,6 +11,7 @@ const tips: string[] = [
 
 export async function run(client: any, interaction: ChatInputCommandInteraction) {
   const commandData = client.commands.map((c: SlashCommand) => c.data);
+  
   const slashCommandData = commandData
     .filter((command: any) => command instanceof SlashCommandBuilder)
     .map((c: any) => `\`${c.name}\``);
diff --git a/commands/limit.ts b/commands/limit.ts
@@ -27,7 +27,7 @@ export const data = new SlashCommandBuilder()
 
 export async function run(client: any, interaction: ChatInputCommandInteraction) {
   const subcommand: string = interaction.options.getSubcommand();
-  const doc = await guildModel.findOne({ GuildId: interaction.guild?.id });
+  const doc = await guildModel.findOne({ GuildId: interaction.guild!.id });
   if (!doc) return interaction.reply({
     content: ClientMessages.ERR_SERVER_NOT_FOUND_ADMIN,
     ephemeral: true
diff --git a/commands/list.ts b/commands/list.ts
@@ -9,7 +9,7 @@ export const data = new SlashCommandBuilder()
   .setDMPermission(false);
 
 export async function run(client: any, interaction: CommandInteraction) {
-  const doc = await guildModel.findOne({ GuildId: interaction.guild?.id });
+  const doc = await guildModel.findOne({ GuildId: interaction.guild!.id });
   if (!doc) return interaction.reply({
     content: ClientMessages.ERR_SERVER_NOT_FOUND_ADMIN,
     ephemeral: true
diff --git a/commands/proxy.ts b/commands/proxy.ts
@@ -26,7 +26,6 @@ export async function run(client: any, interaction: ChatInputCommandInteraction)
   try {
     data = await getProxy(interaction, category);
   } catch(error) {
-    console.error(error);
     if(error instanceof ProxyError) return interaction.editReply({ content: error.message }); else return;
   }
   if(data.dm) {
@@ -41,7 +40,7 @@ export async function run(client: any, interaction: ChatInputCommandInteraction)
 }
 
 export async function autocomplete(client: any, interaction: AutocompleteInteraction) {
-  const doc = await guildModel.findOne({ GuildId: interaction.guild?.id });
+  const doc = await guildModel.findOne({ GuildId: interaction.guild!.id });
   if(!doc) return interaction.respond([]);
   const input: string = interaction.options.getFocused();
   const data: string[] = doc.types.filter(type => type.startsWith(input));
diff --git a/commands/usage.ts b/commands/usage.ts
@@ -8,8 +8,7 @@ export const data = new SlashCommandBuilder()
   .setDMPermission(false);
   
 export async function run(client: any, interaction: ChatInputCommandInteraction) {
-  // @ts-ignore
-  const gid: string = interaction.guild.id;
+  const gid: string = interaction.guild!.id;
   const doc = await guildModel.findOne({ GuildId: gid });
   if(!doc) return interaction.reply({
     content: ClientMessages.ERR_SERVER_NOT_FOUND,
@@ -20,15 +19,15 @@ export async function run(client: any, interaction: ChatInputCommandInteraction)
       content: ClientMessages.ERR_YOU_HAVE_NOT_USED_BOT,
       ephemeral: true
   });
-  if(!user.guilds[gid]) return interaction.reply({
+  if(!user.guilds.has(gid)) return interaction.reply({
     content: ClientMessages.ERR_YOU_HAVE_NOT_USED_BOT,
     ephemeral: true
   });
-
-  const links: string = user.guilds[gid].links.slice(0, doc.limit).join("\n");
+  const userGuild = user.guilds.get(gid)!;
+  const links: string = userGuild.links.slice(0, doc.limit).join("\n");
   const embed = new EmbedBuilder()
     .addFields([
-      { name: "Curent Usage", value: `${user.guilds[gid].uses} (out of ${doc.limit})` },
+      { name: "Curent Usage", value: `${userGuild.uses} (out of ${doc.limit})` },
       { name: `Last ${doc.limit} links`, value: links }
     ]);
   interaction.reply({ embeds: [embed], ephemeral: true });
diff --git a/events/MessageCreate.ts b/events/MessageCreate.ts
diff --git a/events/Ready.ts b/events/Ready.ts
@@ -8,11 +8,11 @@ async function getServerCount(client: DiscordClient) {
 
 async function setPresence(client: DiscordClient) {
   const serverCount = await getServerCount(client);
-  client.user?.setPresence({
+  client.user!.setPresence({
     status: "online",
     activities: [
       {
-        name: `${serverCount} server${serverCount !== 1 ? "s" : ""}${Array.isArray(client.shard?.ids) ? ` | Shard ${client.shard?.ids}` : ""}`,
+        name: `${serverCount} server${serverCount !== 1 ? "s" : ""}${Array.isArray(client.shard?.ids) ? ` | Shard ${client.shard!.ids}` : ""}`,
         type: ActivityType.Watching
       }
     ]
@@ -21,7 +21,7 @@ async function setPresence(client: DiscordClient) {
 
 export default async function registerHandler(client: DiscordClient) {
   client.once(Events.ClientReady, () => {
-    console.log(`Logged in as ${client.user?.tag} (${client.user?.id})`);
+    console.log(`Logged in as ${client.user!.tag} (${client.user!.id})`);
 
     // Register the commands
     const data: any = client.commands.map(command => command?.data);
diff --git a/events/index.ts b/events/index.ts
@@ -1,10 +1,9 @@
 import InteractionCreate from "./InteractionCreate.js";
-import MessageCreate from "./MessageCreate.js";
 import Ready from "./Ready.js";
 
 import type { DiscordClient } from "../lib/types.js";
 
-const handlers = [InteractionCreate, MessageCreate, Ready];
+const handlers = [InteractionCreate, Ready];
 
 export async function loadEventHandlers(client: DiscordClient) {
   for (let handler of handlers) {
diff --git a/index.ts b/index.ts
@@ -7,10 +7,8 @@ import type { DiscordClient, SlashCommand } from "./lib/types.js";
 
 import mongoose from "mongoose";
 
-// We want GuildMessages to tell the users who try to use message commands
-// that we do not use them
 const client = new Client({
-  intents: [GatewayIntentBits.Guilds, GatewayIntentBits.GuildMessages]
+  intents: [GatewayIntentBits.Guilds]
 }) as DiscordClient;
 client.commands = new Collection<String, SlashCommand>();
 
@@ -19,7 +17,7 @@ loadSlashCommands(client);
 
 mongoose.connect(process.env.MONGODB_URI || "").then(() => console.log("MongoDB connected")).catch(err => {
   console.log("Failed to connect to MongoDB");
-  console.log(err);
+  throw err;
 });
 
 client.login();
diff --git a/lib/proxy.ts b/lib/proxy.ts
@@ -22,7 +22,6 @@ export function getProxy(interaction: any, category: string) : Promise<ProxyMess
     const GuildId: string = interaction.guild!.id;
     const UserId = interaction.user.id;
 
-    var _save = false;
     // Find the document with the specified category
     const doc = await guildModel.findOne({ GuildId });
 
@@ -33,36 +32,22 @@ export function getProxy(interaction: any, category: string) : Promise<ProxyMess
     var user: any = await userModel.findOne({ UserId });
 
     if (!user) {
-      user = new userModel({
-        UserId,
-        links: [],
-        guilds: {}
-      });
-      _save = true;
-    }
-    if (!user.guilds[GuildId]) {
-      user.guilds[GuildId] = {
-        uses: 0,
-        links: []
-      };
-      user.markModified(`guilds.${GuildId}`);
-      _save = true;
-    }
-    if (_save) {
+      user = new userModel({ UserId });
       await doc.save();
-      _save = false;
-    }
+    };
+    var userLinks = user.guilds.get(GuildId) || { uses: 0, links: [] };
+
     if (!doc.types.includes(category)) return reject(new ProxyError(ProxyMessages.ERR_CATEGORY_NOT_FOUND.replace("%s", category)));
 
-    if (user && (user.guilds[GuildId].uses) >= LinkLimit) {
+    if (user && (userLinks.uses) >= LinkLimit) {
       return reject(new ProxyError(ProxyMessages.ERR_REACHED_LINK_LIMIT.replace("%s", LinkLimit.toString())));
     }
 
     if (doc.links.length === 0) return reject(new ProxyError(ProxyMessages.ERR_NO_LINKS.replace("%s", category)));
 
     // Select a random link from the document's links array that the user has not already received
     const linksToChooseFrom = doc.links.filter(
-      (link: GuildLink) => !(user.guilds[GuildId].links).includes(link.domain)
+      (link: GuildLink) => !(userLinks.links).includes(link.domain)
     );
     if (linksToChooseFrom.length === 0) return reject(new ProxyError(ProxyMessages.ERR_GOT_ALL_LINKS.replace("%s", category)));
     const randomLink = linksToChooseFrom[Math.floor(Math.random() * linksToChooseFrom.length)];
@@ -73,11 +58,11 @@ export function getProxy(interaction: any, category: string) : Promise<ProxyMess
       .setColor("#4a0f0f")
       .addFields([
         { name: "Domain:", value: `${randomLink.domain}` },
-        { name: "Remaining uses:", value: `${LinkLimit - (user.guilds[GuildId].uses + 1)}` }
+        { name: "Remaining uses:", value: `${LinkLimit - (userLinks.uses + 1)}` }
       ])
       .setFooter({ text: interaction.guild.name, iconURL: interaction.guild.iconURL() });
 
-    if (doc.dmMode && interaction.guild?.members.cache.size < 100 && !doc.isPremium) {
+    if (doc.dmMode && interaction.guild!.members.cache.size < 100 && !doc.isPremium) {
       doc.dmMode = false;
       doc.save();
     }
@@ -86,9 +71,10 @@ export function getProxy(interaction: any, category: string) : Promise<ProxyMess
       dm: doc.dmMode || false,
       data: { embeds: [embed] }
     });
-    user.guilds[GuildId].links.unshift(randomLink.domain);
-    user.guilds[GuildId].uses++;
-    user.markModified(`guilds.${GuildId}`)
+
+    userLinks.links.unshift(randomLink.domain);
+    userLinks.uses++;
+    user.guilds.set(GuildId, userLinks);
     await user.save();
   })
 }
diff --git a/lib/resetUser.ts b/lib/resetUser.ts
@@ -3,10 +3,11 @@ import { userModel } from "./schema.js";
 export default async function resetUser(UserId: string, GuildId: string) {
   const doc: any = await userModel.findOne({ UserId });
   if(!doc) return { done: false };
-  if(!doc.guilds[GuildId]) return { done: false };
-  const oldUsage = doc.guilds[GuildId].uses;
-  doc.guilds[GuildId].uses = 0;
-  doc.markModified(`guilds.${GuildId}`);
+  if(!doc.guilds.has(GuildId)) return { done: false };
+  const uG = doc.guilds.get(GuildId)!;
+  const oldUsage = uG.uses;
+  uG.uses = 0;
+  doc.guilds.set(GuildId, uG);
   await doc.save();
   return {
     done: true,
diff --git a/lib/schema.ts b/lib/schema.ts
@@ -1,16 +1,33 @@
 import mongoose from "mongoose";
 
-export const guildModel = mongoose.model("guild", new mongoose.Schema({
-  GuildId: String,
+const linksSchema = new mongoose.Schema({
+  _id: { type: mongoose.Types.ObjectId, required: true, default: () => new mongoose.Types.ObjectId() },
+  type: { type: String, required: true },
+  domain: { type: String, required: true }
+});
+
+const userGuildSchema = new mongoose.Schema({
+  uses: { type: Number, required: true, default: 0 },
+  links: { type: [String], required: true, default: 0 }
+});
+
+const guildSchema = new mongoose.Schema({
+  GuildId: { type: String, required: true },
   isPremium: Boolean,
   dmMode: Boolean,
-  limit: Number,
-  types: Array,
-  links: Array
-}))
+  limit: { type: Number, required: true },
+  types: { type: [String], required: true, default: [] },
+  links: { type: [linksSchema], required: true, default: [] }
+});
+
+export const guildModel = mongoose.model("guild", guildSchema)
 
 export const userModel = mongoose.model("user", new mongoose.Schema({
-    UserId: String,
-    links: Array,
-    guilds: Object
+  UserId: { type: String, required: true },
+  guilds: {
+    type: Map,
+    of: userGuildSchema,
+    required: true,
+    default: {}
+  }
 }));
diff --git a/lib/viewUser.ts b/lib/viewUser.ts
@@ -13,15 +13,16 @@ export default async function viewUser(user: any, GuildId: string) {
     content: ClientMessages.ERR_USER_NOT_USED_BOT,
     ephemeral: true
   };
-  if(!userData.guilds[GuildId]) return {
+  if(!userData.guilds.has(GuildId)) return {
     content: ClientMessages.ERR_USER_NOT_USED_BOT,
     ephemeral: true
   };
-  const links: string = userData.guilds[GuildId].links.slice(0, doc.limit).join("\n");
+  const userDataGuild = userData.guilds.get(GuildId)!;
+  const links: string = userDataGuild.links.slice(0, doc.limit).join("\n");
   const embed = new EmbedBuilder()
     .setAuthor({ name: `Usage data for ${user.tag}`, iconURL: user.displayAvatarURL() })
     .addFields([
-      { name: "Curent Usage", value: `${userData.guilds[GuildId].uses} (out of ${doc.limit})` },
+      { name: "Curent Usage", value: `${userDataGuild.uses} (out of ${doc.limit})` },
       { name: `Last ${doc.limit} links`, value: links }
     ]);
   return { embeds: [embed], ephemeral: true };
diff --git a/manager.ts b/manager.ts

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-run = ["yarn", "start"]`
	`1`	`+run = ["./node_modules/.bin/ts-node", "--esm", "index.ts"]`
`2`	`2`
`3`	`3`	`[nix]`
`4`	`4`	`channel = "stable-23_05"`