@open-discord-bots/framework 0.3.2 → 0.3.4

package/dist/api/modules/state.js

@@ -0,0 +1,222 @@
+///////////////////////////////////////
+//STATE MODULE
+///////////////////////////////////////
+import { ODManager, ODSystemError, ODManagerData } from "./base.js";
+/**## ODState `class`
+ * An Open Discord state is a system for storing additional chunks of metadata for Discord messages.
+ * A system for tracking messages or linking metadata, states or progress to Discord messages (ID-based).
+ *
+ * Features automatic garbage collection to clear expired states.
+ */
+export class ODState extends ODManagerData {
+    /**Alias to Open Discord message states database. */
+    database;
+    /**Alias to Open Discord client manager. */
+    client;
+    /**Alias to Open Discord debugger. */
+    debug = null;
+    /**The settings of this state. */
+    settings;
+    constructor(id, client, database, settings) {
+        super(id);
+        this.client = client;
+        this.database = database;
+        this.settings = {
+            disableAutodelete: false,
+            autodeleteOnChannelDelete: true,
+            autodeleteOnMessageDelete: true,
+            autodeleteOnUserLeave: true,
+            autodeleteOnRestart: false,
+            autodeleteOnEphemeral: true,
+            autodeleteAfterTimeout: null,
+            ...settings
+        };
+    }
+    /**Use the Open Discord debugger in this manager for logs. */
+    useDebug(debug) {
+        this.debug = debug ?? null;
+    }
+    /**Init the state and start autodeleting. The client must already be logged-in for this to work. */
+    async init() {
+        if (!this.client.loggedIn)
+            throw new ODSystemError("ODState('" + this.id.value + "').init() => The client must be logged in for states to initialize.");
+        //autodelete on restart
+        if (!this.settings.disableAutodelete && this.settings.autodeleteOnRestart)
+            this.clearAllMsgStates();
+        //autodelete on channelDelete
+        this.client.client.on("channelDelete", async (deletedChannel) => {
+            if (this.settings.disableAutodelete || !this.settings.autodeleteOnChannelDelete)
+                return;
+            for (const { key, value } of await this.listMsgStates()) {
+                if (value.channelId === deletedChannel.id)
+                    await this.deleteMsgStateWithRawKey(key);
+            }
+        });
+        //autodelete on messageDelete
+        this.client.client.on("messageDelete", async (deletedMsg) => {
+            if (this.settings.disableAutodelete || !this.settings.autodeleteOnMessageDelete)
+                return;
+            for (const { key, value } of await this.listMsgStates()) {
+                if (value.messageId === deletedMsg.id)
+                    await this.deleteMsgStateWithRawKey(key);
+            }
+        });
+        //autodelete on userLeave
+        this.client.client.on("guildMemberRemove", async (member) => {
+            if (this.settings.disableAutodelete || !this.settings.autodeleteOnUserLeave)
+                return;
+            if (member.guild.id !== this.client.mainServer?.id)
+                return;
+            for (const { key, value } of await this.listMsgStates()) {
+                if (value.userId === member.id)
+                    await this.deleteMsgStateWithRawKey(key);
+            }
+        });
+        //autodelete when expired (ephemeral/timeout) every 30 seconds
+        this.purgeExpiredStates();
+        setInterval(() => {
+            this.purgeExpiredStates();
+        }, 30 * 1000);
+        //create a list of all channels, messages & users that still exist (and are part of states)
+        const existingChannelIds = [];
+        const existingMessageIds = [];
+        const existingUserIds = [];
+        for (const { key, value } of await this.listMsgStates()) {
+            if (!existingChannelIds.includes(value.channelId)) {
+                //check if channel still exists
+                const channel = await this.client.fetchChannel(value.channelId);
+                if (channel)
+                    existingChannelIds.push(channel.id);
+            }
+            if (!existingMessageIds.includes(value.messageId)) {
+                //check if message still exists
+                const message = await this.client.fetchChannelMessage(value.channelId, value.messageId);
+                if (message)
+                    existingMessageIds.push(message.id);
+            }
+            if (value.userId && this.client.mainServer && !existingUserIds.includes(value.userId)) {
+                //check if user still exists
+                const user = await this.client.fetchGuildMember(this.client.mainServer.id, value.userId);
+                if (user)
+                    existingUserIds.push(user.id);
+            }
+        }
+        //delete all states where a channel, message or user is missing (when the bot was offline)
+        for (const { key, value } of await this.listMsgStates()) {
+            if (value.channelId && !existingChannelIds.includes(value.channelId))
+                await this.deleteMsgStateWithRawKey(key);
+            if (value.messageId && !existingMessageIds.includes(value.messageId))
+                await this.deleteMsgStateWithRawKey(key);
+            if (value.userId && !existingUserIds.includes(value.userId))
+                await this.deleteMsgStateWithRawKey(key);
+        }
+    }
+    /**Purge all expired message states that reached a timeout or ephemeral. */
+    async purgeExpiredStates() {
+        for (const { key, value } of await this.listMsgStates()) {
+            if (value.deleteAfterDate && value.deleteAfterDate < Date.now())
+                await this.deleteMsgStateWithRawKey(key);
+        }
+    }
+    /**Transform the object-based message state key contents to a string. */
+    transformKey(key) {
+        const newGuild = (!key.guild) ? "NULL" : (typeof key.guild === "string" ? key.guild : key.guild.id);
+        const newChannel = (!key.channel) ? "NULL" : (typeof key.channel === "string" ? key.channel : key.channel.id);
+        const newMessage = (!key.message) ? "NULL" : (typeof key.message === "string" ? key.message : key.message.id);
+        const newUser = (!key.user) ? "NULL" : (typeof key.user === "string" ? key.user : key.user.id);
+        return `G:${newGuild},C:${newChannel},M:${newMessage},U:${newUser}`;
+    }
+    /**Transform the message state data contents for storage in the database. */
+    transformData(key, data, isEphemeral, keepCreatedDate) {
+        const guildId = (!key.guild) ? null : (typeof key.guild === "string" ? key.guild : key.guild.id);
+        const channelId = (typeof key.channel === "string" ? key.channel : key.channel.id);
+        const messageId = (typeof key.message === "string" ? key.message : key.message.id);
+        const userId = (!key.user) ? null : (typeof key.user === "string" ? key.user : key.user.id);
+        const createdDate = keepCreatedDate ?? Date.now();
+        const modifiedDate = Date.now();
+        const unmodifiedTimeoutDate = this.timeoutToUnixTime();
+        const ephemeralTimeoutDate = (isEphemeral) ? Date.now() + (3600 * 1000) : null; //delete ephemeral state after 1 hour
+        const deleteAfterDate = (unmodifiedTimeoutDate) ? unmodifiedTimeoutDate : ephemeralTimeoutDate;
+        return { guildId, channelId, messageId, userId, createdDate, modifiedDate, deleteAfterDate, data };
+    }
+    /**Calculate milliseconds from a time + unit. */
+    timeoutToUnixTime() {
+        const timeout = this.settings.autodeleteAfterTimeout;
+        if (!timeout)
+            return null;
+        if (timeout.unit == "seconds")
+            return Date.now() + (timeout.time * 1000);
+        else if (timeout.unit == "minutes")
+            return Date.now() + (timeout.time * 1000 * 60);
+        else if (timeout.unit == "hours")
+            return Date.now() + (timeout.time * 1000 * 3600);
+        else if (timeout.unit == "days")
+            return Date.now() + (timeout.time * 1000 * 3600 * 24);
+        else
+            return null;
+    }
+    /**Set a message state using guild, channel & message id as key. Returns `true` when overwritten. */
+    async setMsgState(key, data, isEphemeral) {
+        const rawKey = this.transformKey(key);
+        const existingData = await this.getMsgState(key);
+        const contents = this.transformData(key, data, isEphemeral, existingData?.createdDate);
+        return await this.database.set(this.id.value, rawKey, contents);
+    }
+    /**Get a message state using guild, channel & message id as key. */
+    async getMsgState(key) {
+        const rawKey = this.transformKey(key);
+        const rawData = await this.database.get(this.id.value, rawKey);
+        if (typeof rawData !== "object")
+            return null;
+        else
+            return rawData;
+    }
+    /**Delete a message state using guild, channel & message id as key. Returns `true` when deleted. */
+    async deleteMsgState(key) {
+        const rawKey = this.transformKey(key);
+        return await this.database.delete(this.id.value, rawKey);
+    }
+    /**List all message states of this `ODState`. */
+    async listMsgStates() {
+        return ((await this.database.getCategory(this.id.value)) ?? []);
+    }
+    /**Delete all message states from this ODState. */
+    async clearAllMsgStates() {
+        for (const state of await this.database.getAll()) {
+            await this.database.delete(state.category, state.key);
+        }
+    }
+    /**Delete a message state using the raw key. Returns `true` when deleted. */
+    async deleteMsgStateWithRawKey(rawKey) {
+        return await this.database.delete(this.id.value, rawKey);
+    }
+}
+/**## ODStateManager `class`
+ * The Open Discord state manager is a system for tracking messages or linking metadata, states or progress to Discord messages (ID-based).
+ *
+ * Features automatic garbage collection to clear expired states.
+ */
+export class ODStateManager extends ODManager {
+    constructor(debug) {
+        super(debug, "state");
+    }
+    /**Init all states. */
+    async init() {
+        for (const state of this.getAll()) {
+            await state.init();
+        }
+    }
+    add(data, overwrite) {
+        data.useDebug(this.debug);
+        return super.add(data, overwrite);
+    }
+    get(id) {
+        return super.get(id);
+    }
+    remove(id) {
+        return super.remove(id);
+    }
+    exists(id) {
+        return super.exists(id);
+    }
+}

package/dist/startup/errorHandling.js

@@ -1,5 +1,7 @@
 import * as api from "../api/index.js";
 export function loadErrorHandling(opendiscord, project) {
+    //increase error stack trace
+    Error.stackTraceLimit = 50;
     process.on("uncaughtException", async (error, origin) => {
         try {
             const beforeEvent = opendiscord.events.get("onErrorHandling");

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@open-discord-bots/framework",
     "author": "DJj123dj",
-    "version": "0.3.2",
+    "version": "0.3.4",
     "description": "The core framework of the popular open-source discord bots: Open Ticket & Open Moderation.",
     "main": "dist/index.js",
     "module": "dist/index.js",

package/src/api/index.ts

@@ -25,6 +25,7 @@ export * from "./modules/progressbar.js"
 export * from "./modules/responder.js"
 export * from "./modules/session.js"
 export * from "./modules/startscreen.js"
+export * from "./modules/state.js"
 export * from "./modules/statistic.js"
 export * from "./modules/verifybar.js"
 export * from "./modules/worker.js"

package/src/api/main.ts

@@ -24,6 +24,7 @@ import { ODClientManager } from "./modules/client.js"
 import { ODSharedFuseManager } from "./modules/fuse.js"
 import { ODStartScreenManager } from "./modules/startscreen.js"
 import { ODComponentManager } from "./modules/component.js"
+import { ODStateManager } from "./modules/state.js"
 
 /**## ODMainManagers `interface`
  * The global properties for the main class of the bot.
@@ -89,6 +90,8 @@ export interface ODMainManagers {
     code: ODCodeManager
     /**A collection of static Discord post channels. It allows the bot to find back log, transcript or configured channels based on a linked ID. */
     posts: ODPostManager
+    /**A system for tracking messages or linking metadata, states or progress to Discord messages (ID-based). Features automatic garbage collection. */
+    states: ODStateManager
     
     /**A wrapper around the `discord.Client` class. It handles client login, activity and registering text/slash commands. */
     client: ODClientManager
@@ -140,6 +143,7 @@ export abstract class ODMain implements ODMainManagers {
     readonly statistics: ODStatisticManager
     readonly code: ODCodeManager
     readonly posts: ODPostManager
+    readonly states: ODStateManager
     
     readonly client: ODClientManager
     readonly sharedFuses: ODSharedFuseManager
@@ -150,7 +154,7 @@ export abstract class ODMain implements ODMainManagers {
     constructor(managers:ODMainManagers,project:ODProjectType){
         this.project = project
         this.versions = managers.versions
-        this.versions.add(ODVersion.fromString("opendiscord:api","v0.3.2"))
+        this.versions.add(ODVersion.fromString("opendiscord:api","v0.3.4"))
         this.versions.add(ODVersion.fromString("opendiscord:livestatus","v2.0.0"))
 
         this.debugfile = managers.debugfile
@@ -179,6 +183,7 @@ export abstract class ODMain implements ODMainManagers {
         this.statistics = managers.statistics
         this.code = managers.code
         this.posts = managers.posts
+        this.states = managers.states
         
         this.sharedFuses = managers.sharedFuses
         this.env = managers.env

package/src/api/modules/client.ts

@@ -123,7 +123,7 @@ export class ODClientManager<SlashIdList extends ODSlashCommandManagerIdConstrai
     }
     /**Get all servers the bot is part of. */
     async getGuilds(): Promise<discord.Guild[]> {
-        if (!this.initiated) throw new ODSystemError("Client isn't initiated yet!")
+        if (!this.initiated) throw new ODSystemError("ODClientManager() => Unable to use this method. Client isn't initiated yet.")
         if (!this.ready) throw new ODSystemError("Client isn't ready yet!")
         
         return this.client.guilds.cache.map((guild) => guild)
@@ -146,15 +146,15 @@ export class ODClientManager<SlashIdList extends ODSlashCommandManagerIdConstrai
     /**Log-in with a discord auth token. Rejects returns `false` using 'softErrors' on failure. */
     login(softErrors?:boolean): Promise<boolean> {
         return new Promise(async (resolve,reject) => {
-            if (!this.initiated) reject("Client isn't initiated yet!")
-            if (!this.token) reject("Client doesn't have a token!")
+            if (!this.initiated) reject("ODClientManager.login() => Unable to use this method. Client isn't initiated yet.")
+            if (!this.token) reject("ODClientManager.login() => Unable to login, client does not have a token.")
             
             try {
                 this.client.once("clientReady",async () => {
                     this.ready = true
 
                     //set slashCommandManager & contextMenuManager to client applicationCommandManager
-                    if (!this.client.application) throw new ODSystemError("Couldn't get client application for slashCommand & contextMenu managers!")
+                    if (!this.client.application) throw new ODSystemError("ODClientManager.login() => Unable to fetch client application for slashCommand & contextMenu managers.")
                     this.slashCommands.commandManager = this.client.application.commands
                     this.contextMenus.commandManager = this.client.application.commands
                     this.autocompletes.commandManager = this.client.application.commands
@@ -177,10 +177,10 @@ export class ODClientManager<SlashIdList extends ODSlashCommandManagerIdConstrai
             }
         })
     }
-    /**A simplified shortcut to get a `discord.User` :) */
+    /**A simplified shortcut to get a `discord.User`. */
     async fetchUser(id:string): Promise<discord.User|null> {
-        if (!this.initiated) throw new ODSystemError("Client isn't initiated yet!")
-        if (!this.ready) throw new ODSystemError("Client isn't ready yet!")
+        if (!this.initiated) throw new ODSystemError("ODClientManager.fetchUser() => Unable to use this method. Client isn't initiated yet.")
+        if (!this.ready) throw new ODSystemError("ODClientManager.fetchUser() => Unable to use this method. Client isn't ready and logged in yet.")
 
         try{
             return await this.client.users.fetch(id)
@@ -188,10 +188,10 @@ export class ODClientManager<SlashIdList extends ODSlashCommandManagerIdConstrai
             return null
         }
     }
-    /**A simplified shortcut to get a `discord.Guild` :) */
+    /**A simplified shortcut to get a `discord.Guild`. */
     async fetchGuild(id:string): Promise<discord.Guild|null> {
-        if (!this.initiated) throw new ODSystemError("Client isn't initiated yet!")
-        if (!this.ready) throw new ODSystemError("Client isn't ready yet!")
+        if (!this.initiated) throw new ODSystemError("ODClientManager.fetchGuild() => Unable to use this method. Client isn't initiated yet.")
+        if (!this.ready) throw new ODSystemError("ODClientManager.fetchGuild() => Unable to use this method. Client isn't ready and logged in yet.")
 
         try{
             return await this.client.guilds.fetch(id)
@@ -199,10 +199,10 @@ export class ODClientManager<SlashIdList extends ODSlashCommandManagerIdConstrai
             return null
         }
     }
-    /**A simplified shortcut to get a `discord.Channel` :) */
+    /**A simplified shortcut to get a `discord.Channel`. */
     async fetchChannel(id:string): Promise<discord.Channel|null> {
-        if (!this.initiated) throw new ODSystemError("Client isn't initiated yet!")
-        if (!this.ready) throw new ODSystemError("Client isn't ready yet!")
+        if (!this.initiated) throw new ODSystemError("ODClientManager.fetchChannel() => Unable to use this method. Client isn't initiated yet.")
+        if (!this.ready) throw new ODSystemError("ODClientManager.fetchChannel() => Unable to use this method. Client isn't ready and logged in yet.")
 
         try{
             return await this.client.channels.fetch(id)
@@ -210,10 +210,23 @@ export class ODClientManager<SlashIdList extends ODSlashCommandManagerIdConstrai
             return null
         }
     }
-    /**A simplified shortcut to get a `discord.GuildBasedChannel` :) */
+    /**A simplified shortcut to get a `discord.TextChannel` (guild or DM). */
+    async fetchTextChannel(id:string): Promise<discord.TextChannel|discord.DMChannel|discord.PartialDMChannel|null> {
+        if (!this.initiated) throw new ODSystemError("ODClientManager.fetchTextChannel() => Unable to use this method. Client isn't initiated yet.")
+        if (!this.ready) throw new ODSystemError("ODClientManager.fetchTextChannel() => Unable to use this method. Client isn't ready and logged in yet.")
+
+        try{
+            const channel = await this.client.channels.fetch(id)
+            if (!channel || (channel.type != discord.ChannelType.GuildText && channel.type != discord.ChannelType.DM)) return null
+            return channel
+        }catch{
+            return null
+        }
+    }
+    /**A simplified shortcut to get a `discord.GuildBasedChannel`. */
     async fetchGuildChannel(guildId:string|discord.Guild, id:string): Promise<discord.GuildBasedChannel|null> {
-        if (!this.initiated) throw new ODSystemError("Client isn't initiated yet!")
-        if (!this.ready) throw new ODSystemError("Client isn't ready yet!")
+        if (!this.initiated) throw new ODSystemError("ODClientManager.fetchGuildChannel() => Unable to use this method. Client isn't initiated yet.")
+        if (!this.ready) throw new ODSystemError("ODClientManager.fetchGuildChannel() => Unable to use this method. Client isn't ready and logged in yet.")
 
         try{
             const guild = (guildId instanceof discord.Guild) ? guildId : await this.fetchGuild(guildId)
@@ -224,10 +237,10 @@ export class ODClientManager<SlashIdList extends ODSlashCommandManagerIdConstrai
             return null
         }
     }
-    /**A simplified shortcut to get a `discord.TextChannel` :) */
+    /**A simplified shortcut to get a `discord.TextChannel`. */
     async fetchGuildTextChannel(guildId:string|discord.Guild, id:string): Promise<discord.TextChannel|null> {
-        if (!this.initiated) throw new ODSystemError("Client isn't initiated yet!")
-        if (!this.ready) throw new ODSystemError("Client isn't ready yet!")
+        if (!this.initiated) throw new ODSystemError("ODClientManager.fetchGuildTextChannel() => Unable to use this method. Client isn't initiated yet.")
+        if (!this.ready) throw new ODSystemError("ODClientManager.fetchGuildTextChannel() => Unable to use this method. Client isn't ready and logged in yet.")
 
         try{
             const guild = (guildId instanceof discord.Guild) ? guildId : await this.fetchGuild(guildId)
@@ -239,10 +252,10 @@ export class ODClientManager<SlashIdList extends ODSlashCommandManagerIdConstrai
             return null
         }
     }
-    /**A simplified shortcut to get a `discord.CategoryChannel` :) */
+    /**A simplified shortcut to get a `discord.CategoryChannel`. */
     async fetchGuildCategoryChannel(guildId:string|discord.Guild, id:string): Promise<discord.CategoryChannel|null> {
-        if (!this.initiated) throw new ODSystemError("Client isn't initiated yet!")
-        if (!this.ready) throw new ODSystemError("Client isn't ready yet!")
+        if (!this.initiated) throw new ODSystemError("ODClientManager.fetchGuildCategoryChannel() => Unable to use this method. Client isn't initiated yet.")
+        if (!this.ready) throw new ODSystemError("ODClientManager.fetchGuildCategoryChannel() => Unable to use this method. Client isn't ready and logged in yet.")
 
         try{
             const guild = (guildId instanceof discord.Guild) ? guildId : await this.fetchGuild(guildId)
@@ -254,12 +267,11 @@ export class ODClientManager<SlashIdList extends ODSlashCommandManagerIdConstrai
             return null
         }
     }
-    /**A simplified shortcut to get a `discord.GuildMember` :) */
+    /**A simplified shortcut to get a `discord.GuildMember`. */
     async fetchGuildMember(guildId:string|discord.Guild, id:string): Promise<discord.GuildMember|null> {
-        if (!this.initiated) throw new ODSystemError("Client isn't initiated yet!")
-        if (!this.ready) throw new ODSystemError("Client isn't ready yet!")
-        if (typeof id != "string") throw new ODSystemError("TEMP ERROR => ODClientManager.fetchGuildMember() => id param isn't string")
-
+        if (!this.initiated) throw new ODSystemError("ODClientManager.fetchGuildMember() => Unable to use this method. Client isn't initiated yet.")
+        if (!this.ready) throw new ODSystemError("ODClientManager.fetchGuildMember() => Unable to use this method. Client isn't ready and logged in yet.")
+        
         try{
             const guild = (guildId instanceof discord.Guild) ? guildId : await this.fetchGuild(guildId)
             if (!guild) return null
@@ -268,12 +280,11 @@ export class ODClientManager<SlashIdList extends ODSlashCommandManagerIdConstrai
             return null
         }
     }
-    /**A simplified shortcut to get a `discord.Role` :) */
+    /**A simplified shortcut to get a `discord.Role`. */
     async fetchGuildRole(guildId:string|discord.Guild, id:string): Promise<discord.Role|null> {
-        if (!this.initiated) throw new ODSystemError("Client isn't initiated yet!")
-        if (!this.ready) throw new ODSystemError("Client isn't ready yet!")
-        if (typeof id != "string") throw new ODSystemError("TEMP ERROR => ODClientManager.fetchGuildRole() => id param isn't string")
-
+        if (!this.initiated) throw new ODSystemError("ODClientManager.fetchGuildRole() => Unable to use this method. Client isn't initiated yet.")
+        if (!this.ready) throw new ODSystemError("ODClientManager.fetchGuildRole() => Unable to use this method. Client isn't ready and logged in yet.")
+        
         try{
             const guild = (guildId instanceof discord.Guild) ? guildId : await this.fetchGuild(guildId)
             if (!guild) return null
@@ -282,30 +293,23 @@ export class ODClientManager<SlashIdList extends ODSlashCommandManagerIdConstrai
             return null
         }
     }
-    /**A simplified shortcut to get a `discord.Message` :) */
-    async fetchGuildChannelMessage(guildId:string|discord.Guild, channelId:string|discord.TextChannel, id:string): Promise<discord.Message<true>|null>
-    async fetchGuildChannelMessage(channelId:discord.TextChannel, id:string): Promise<discord.Message<true>|null>
-    async fetchGuildChannelMessage(guildId:string|discord.Guild|discord.TextChannel, channelId:string|discord.TextChannel|string, id?:string): Promise<discord.Message<true>|null> {
-        if (!this.initiated) throw new ODSystemError("Client isn't initiated yet!")
-        if (!this.ready) throw new ODSystemError("Client isn't ready yet!")
+    /**A simplified shortcut to get a `discord.Message`. */
+    async fetchChannelMessage(channelId:string|discord.TextChannel|discord.DMChannel, id:string): Promise<discord.Message<boolean>|null> {
+        if (!this.initiated) throw new ODSystemError("ODClientManager.fetchChannelMessage() => Unable to use this method. Client isn't initiated yet.")
+        if (!this.ready) throw new ODSystemError("ODClientManager.fetchChannelMessage() => Unable to use this method. Client isn't ready and logged in yet.")
 
         try{
-            if (guildId instanceof discord.TextChannel && typeof channelId == "string"){
-                const channel = guildId
-                return await channel.messages.fetch(channelId)
-            }else if (!(guildId instanceof discord.TextChannel) && id){
-                const channel = (channelId instanceof discord.TextChannel) ? channelId : await this.fetchGuildTextChannel(guildId,channelId)
-                if (!channel) return null
-                return await channel.messages.fetch(id)
-            }else return null
+            const channel = (channelId instanceof discord.TextChannel || channelId instanceof discord.DMChannel) ? channelId : await this.fetchTextChannel(channelId)
+            if (!channel) return null
+            return await channel.messages.fetch(id)
         }catch{
             return null
         }
     }
-    /**A simplified shortcut to send a DM to a user :) */
+    /**A simplified shortcut to send a DM to a user. */
     async sendUserDm(user:string|discord.User, build:ODMessageBuildResult|ODMessageComponentBuildResult): Promise<ODResponderSendResult<false>> {
-        if (!this.initiated) throw new ODSystemError("Client isn't initiated yet!")
-        if (!this.ready) throw new ODSystemError("Client isn't ready yet!")
+        if (!this.initiated) throw new ODSystemError("ODClientManager.sendUserDm() => Unable to use this method. Client isn't initiated yet.")
+        if (!this.ready) throw new ODSystemError("ODClientManager.sendUserDm() => Unable to use this method. Client isn't ready and logged in yet.")
 
         try{
             const msgFlags: number[] = []
@@ -325,26 +329,26 @@ export class ODClientManager<SlashIdList extends ODSlashCommandManagerIdConstrai
             const finalMessage = Object.assign(msgData,{flags:msgFlags})
 
             if (user instanceof discord.User){
-                if (user.bot) return {success:false,message:null}
+                if (user.bot) return {success:false}
                 const channel = await user.createDM()
                 const msg = await channel.send(finalMessage)
                 return {success:true,message:msg}
             }else{
                 const newUser = await this.fetchUser(user)
                 if (!newUser) throw new Error()
-                if (newUser.bot) return {success:false,message:null}
+                if (newUser.bot) return {success:false}
                 const channel = await newUser.createDM()
                 const msg = await channel.send(finalMessage)
                 return {success:true,message:msg}
             }
         }catch{
             try{
-                this.debug.console.log("Failed to send DM to user! ","warning",[
+                this.debug.console.log("ODClientManager.sendUserDm() => Failed to send DM. User may have DMs disabled for non-friends. ","warning",[
                     {key:"id",value:(user instanceof discord.User ? user.id : user)},
                     {key:"message-build",value:build.id.value}
                 ])
             }catch{}
-            return {success:false,message:null}
+            return {success:false}
         }
     }
 }
@@ -417,7 +421,7 @@ export class ODClientActivityManager {
 
     /**Update the client status */
     private updateClientActivity(type:ODClientActivityType,text:string){
-        if (!this.client.client.user) throw new ODSystemError("Couldn't set client status: client.user == undefined")
+        if (!this.client.client.user) throw new ODSystemError("ODClientActivityManager.updateClientActivity() => Couldn't set client status: client.user is 'undefined'.")
         if (type == false){
             this.client.client.user.setActivity()
             return

package/src/api/modules/console.ts

@@ -217,7 +217,9 @@ export class ODError {
     }
     /**Create a more-detailed, non-colored version of this error to store it in the `debug.txt` file! */
     toDebugString(){
-        return "[UNKNOWN OD ERROR]: "+this.error.message+" | origin: "+this.origin+"\n"+this.error.stack
+        const date = new Date()
+        const dstring = `${date.getDate()}/${date.getMonth()+1}/${date.getFullYear()} ${date.getHours()}:${date.getMinutes()}:${date.getSeconds()}`
+        return "["+dstring+" UNKNOWN OPENDISCORD ERROR]: "+this.error.message+" | Error Origin: "+this.origin+" | Stacktrace:\n"+this.error.stack
     }
 }
 

package/src/api/modules/database.ts

@@ -89,7 +89,7 @@ export abstract class ODDatabase<IdList extends ODDatabaseIdConstraint = ODDatab
     abstract get(category:string, key:string): ODOptionalPromise<ODValidJsonType|undefined>
     abstract get(category:string, key:string): ODOptionalPromise<ODValidJsonType|undefined>
     
-    /**Delete a specific category & key in the database */
+    /**Delete a specific category & key in the database. Returns `true` when deleted. */
     abstract delete<CategoryId extends keyof ODNoGeneric<IdList>>(category:CategoryId, key:string): ODOptionalPromise<boolean>
     abstract delete(category:string, key:string): ODOptionalPromise<boolean>
     abstract delete(category:string, key:string): ODOptionalPromise<boolean>

package/src/api/modules/fuse.ts

@@ -142,9 +142,6 @@ export interface ODSharedFuseList {
     /**Load the default Open Discord client activity initialization (& status refresh). */
     clientActivityInitiating:boolean,
 
-    /**Load the default Open Discord priority levels. */
-    priorityLoading:boolean,
-
     /**Load the default Open Discord slash commands. */
     slashCommandLoading:boolean,
     /**Load the default Open Discord slash command registerer (register slash cmds in discord). */
@@ -164,6 +161,11 @@ export interface ODSharedFuseList {
     /**Load the default Open Discord text commands. */
     textCommandLoading:boolean,
 
+    /**Load the default Open Discord message states. */
+    stateLoading:boolean,
+    /**Initiate the default Open Discord message states. */
+    stateInitiating:boolean,
+
     /**Load the default Open Discord button builders. */
     buttonBuildersLoading:boolean,
     /**Load the default Open Discord dropdown builders. */
@@ -177,6 +179,13 @@ export interface ODSharedFuseList {
     /**Load the default Open Discord modal builders. */
     modalBuildersLoading:boolean,
 
+    /**Load the default Open Discord shared components. */
+    sharedComponentsLoading:boolean,
+    /**Load the default Open Discord message components. */
+    messageComponentsLoading:boolean,
+    /**Load the default Open Discord modal components. */
+    modalComponentsLoading:boolean,
+
     /**Load the default Open Discord command responders. */
     commandRespondersLoading:boolean,
     /**Load the default Open Discord button responders. */
@@ -291,8 +300,6 @@ export class ODSharedFuseManager extends ODFuseManager<ODSharedFuseList> {
             clientActivityLoading:true,
             clientActivityInitiating:true,
 
-            priorityLoading:true,
-            
             slashCommandLoading:true,
             slashCommandRegistering:true,
             forceSlashCommandRegistration:false,
@@ -303,6 +310,9 @@ export class ODSharedFuseManager extends ODFuseManager<ODSharedFuseList> {
             allowContextMenuRemoval:true,
             textCommandLoading:true,
 
+            stateLoading:true,
+            stateInitiating:true,
+
             buttonBuildersLoading:true,
             dropdownBuildersLoading:true,
             fileBuildersLoading:true,
@@ -310,6 +320,10 @@ export class ODSharedFuseManager extends ODFuseManager<ODSharedFuseList> {
             messageBuildersLoading:true,
             modalBuildersLoading:true,
 
+            sharedComponentsLoading:true,
+            messageComponentsLoading:true,
+            modalComponentsLoading:true,
+
             commandRespondersLoading:true,
             buttonRespondersLoading:true,
             dropdownRespondersLoading:true,

package/src/api/modules/post.ts

@@ -107,13 +107,13 @@ export class ODPost<ChannelType extends discord.GuildBasedChannel> extends ODMan
     }
     /**Send a message to this channel using the Open Discord builder system */
     async send(build:ODMessageBuildResult|ODMessageComponentBuildResult): Promise<ODResponderSendResult<true>> {
-        if (!this.channel || !this.channel.isTextBased()) return {success:false,message:null}
+        if (!this.channel || !this.channel.isTextBased()) return {success:false}
         try{
             const finalMessage = this.getMessageFromBuildResult(build,"message")
             const sent = await this.channel.send(finalMessage)
             return {success:true,message:sent}
         }catch{
-            return {success:false,message:null}
+            return {success:false}
         }
     }
     /**Get the final `messageCreateOptions` from a returned build result from builders/components. */