@open-discord-bots/framework 0.0.1 → 0.0.2

package/src/api/modules/permission.ts

@@ -0,0 +1,340 @@
+///////////////////////////////////////
+//PERMISSION MODULE
+///////////////////////////////////////
+import { ODId, ODValidId, ODManager, ODSystemError, ODManagerData } from "./base"
+import * as discord from "discord.js"
+import { ODDebugger } from "./console"
+import { ODClientManager } from "./client"
+
+/**## ODPermissionType `type`
+ * All available permission types/levels. Can be used in the `ODPermission` class.
+ */
+export type ODPermissionType = "member"|"support"|"moderator"|"admin"|"owner"|"developer"
+
+/**## ODPermissionScope `type`
+ * The scope in which a certain permission is active.
+ */
+export type ODPermissionScope = "global-user"|"channel-user"|"global-role"|"channel-role"
+
+/**## ODPermissionResult `interface`
+ * The result returned by `ODPermissionManager.getPermissions()`.
+ */
+export interface ODPermissionResult {
+    /**The permission type. */
+    type:ODPermissionType
+    /**The permission scope. */
+    scope:ODPermissionScope|"default"
+    /**The highest level available for this scope. */
+    level:ODPermissionLevel,
+    /**The permission which returned this level. */
+    source:ODPermission|null
+}
+
+/**## ODPermissionLevel `enum`
+ * All available permission types/levels. But as `enum` instead of `type`. Used to calculate the level.
+ */
+export enum ODPermissionLevel {
+    /**A normal member. (Default for everyone) */
+    member,
+    /**Support team. Higher than a normal member. (Used for ticket-admins) */
+    support,
+    /**Moderator. Higher than the support team. (Unused) */
+    moderator,
+    /**Admin. Higher than a moderator. (Used for global-admins) */
+    admin,
+    /**Server owner. (Able to use all commands including `/stats reset`) */
+    owner,
+    /**Bot owner or all users from dev team. (Able to use all commands including `/stats reset`) */
+    developer
+}
+
+/**## ODPermission `class`
+ * This is an Open Discord permission.
+ * 
+ * It defines a single permission level for a specific scope (global/channel & user/role)
+ * These permissions only apply to commands & interactions.
+ * They are not related to channel permissions in the ticket system.
+ * 
+ * Register this class to an `ODPermissionManager` to use it!
+ */
+export class ODPermission extends ODManagerData {
+    /**The scope of this permission. */
+    readonly scope: ODPermissionScope
+    /**The type/level of this permission. */
+    readonly permission: ODPermissionType
+    /**The user/role of this permission. */
+    readonly value: discord.Role|discord.User
+    /**The channel that this permission applies to. (`null` when global) */
+    readonly channel: discord.Channel|null
+
+    constructor(id:ODValidId, scope:"global-user", permission:ODPermissionType, value:discord.User)
+    constructor(id:ODValidId, scope:"global-role", permission:ODPermissionType, value:discord.Role)
+    constructor(id:ODValidId, scope:"channel-user", permission:ODPermissionType, value:discord.User, channel:discord.Channel)
+    constructor(id:ODValidId, scope:"channel-role", permission:ODPermissionType, value:discord.Role, channel:discord.Channel)
+    constructor(id:ODValidId, scope:ODPermissionScope, permission:ODPermissionType, value:discord.Role|discord.User, channel?:discord.Channel){
+        super(id)
+        this.scope = scope
+        this.permission = permission
+        this.value = value
+        this.channel = channel ?? null
+    }
+}
+
+/**## ODPermissionSettings `interface`
+ * Optional settings for the `getPermissions()` method in the `ODPermissionManager`.
+ */
+export interface ODPermissionSettings {
+    /**Include permissions from the global user scope. */
+    allowGlobalUserScope?:boolean,
+    /**Include permissions from the global role scope. */
+    allowGlobalRoleScope?:boolean,
+    /**Include permissions from the channel user scope. */
+    allowChannelUserScope?:boolean,
+    /**Include permissions from the channel role scope. */
+    allowChannelRoleScope?:boolean,
+    /**Only include permissions of which the id matches this regex. */
+    idRegex?:RegExp
+}
+
+/**## ODPermissionCalculationCallback `type`
+ * The callback of the permission calculation. (Used in `ODPermissionManager`)
+ */
+export type ODPermissionCalculationCallback = (user:discord.User, channel?:discord.Channel|null, guild?:discord.Guild|null, settings?:ODPermissionSettings|null) => Promise<ODPermissionResult>
+
+/**## ODPermissionCommandResult `type`
+ * The result of calculating permissions for a command.
+ */
+export type ODPermissionCommandResult = {
+    /**Returns `true` when the user has valid permissions. */
+    hasPerms:false,
+    reason:"no-perms"|"disabled"|"not-in-server"
+}|{
+    /**Returns `true` when the user has valid permissions. */
+    hasPerms:true,
+    /**Is the user a server admin or a normal member? This does not decide if the user has permissions or not. */
+    isAdmin:boolean
+}
+
+/**## ODPermissionManager `class`
+ * This is an Open Discord permission manager.
+ * 
+ * It manages all permissions in the bot!
+ * Use the `getPermissions()` and `hasPermissions()` methods to get user perms.
+ * 
+ * Add new permissions using the `ODPermission` class in your plugin!
+ */
+export class ODPermissionManager extends ODManager<ODPermission> {
+    /**Alias for Open Discord debugger. */
+    #debug: ODDebugger
+    /**The function for calculating permissions in this manager. */
+    #calculation: ODPermissionCalculationCallback|null
+    /**An alias to the Open Discord client manager. */
+    #client: ODClientManager
+    /**The result which is returned when no other permissions match. (`member` by default) */
+    defaultResult: ODPermissionResult = {
+        level:ODPermissionLevel["member"],
+        scope:"default",
+        type:"member",
+        source:null
+    }
+
+    constructor(debug:ODDebugger, client:ODClientManager, useDefaultCalculation?:boolean){
+        super(debug,"permission")
+        this.#debug = debug
+        this.#calculation = useDefaultCalculation ? this.#defaultCalculation : null
+        this.#client = client
+    }
+
+    /**Edit the permission calculation function in this manager. */
+    setCalculation(calculation:ODPermissionCalculationCallback){
+        this.#calculation = calculation
+    }
+    /**Edit the result which is returned when no other permissions match. (`member` by default) */
+    setDefaultResult(result:ODPermissionResult){
+        this.defaultResult = result
+    }
+    /**Get an `ODPermissionResult` based on a few context factors. Use `hasPermissions()` to simplify the result. */
+    getPermissions(user:discord.User, channel?:discord.Channel|null, guild?:discord.Guild|null, settings?:ODPermissionSettings|null): Promise<ODPermissionResult> {
+        try{
+            if (!this.#calculation) throw new ODSystemError("ODPermissionManager:getPermissions() => missing perms calculation")
+            return this.#calculation(user,channel,guild,settings)
+        }catch(err){
+            process.emit("uncaughtException",err)
+            throw new ODSystemError("ODPermissionManager:getPermissions() => failed perms calculation")
+        }
+    }
+    /**Simplifies the `ODPermissionResult` returned from `getPermissions()` and returns a boolean to check if the user matches the required permissions. */
+    hasPermissions(minimum:ODPermissionType, data:ODPermissionResult){
+        if (minimum == "member") return true
+        else if (minimum == "support") return (data.level >= ODPermissionLevel["support"])
+        else if (minimum == "moderator") return (data.level >= ODPermissionLevel["moderator"])
+        else if (minimum == "admin") return (data.level >= ODPermissionLevel["admin"])
+        else if (minimum == "owner") return (data.level >= ODPermissionLevel["owner"])
+        else if (minimum == "developer") return (data.level >= ODPermissionLevel["developer"])
+        else throw new ODSystemError("Invalid minimum permission type at ODPermissionManager.hasPermissions()")
+    }
+    /**Check for permissions. (default calculation) */
+    async #defaultCalculation(user:discord.User,channel?:discord.Channel|null,guild?:discord.Guild|null, settings?:ODPermissionSettings|null): Promise<ODPermissionResult> {
+        const globalCalc = await this.#defaultGlobalCalculation(user,channel,guild,settings)
+        const channelCalc = await this.#defaultChannelCalculation(user,channel,guild,settings)
+
+        if (globalCalc.level > channelCalc.level) return globalCalc
+        else return channelCalc
+    }
+    /**Check for global permissions. Result will be compared with the channel perms in `#defaultCalculation()`. */
+    async #defaultGlobalCalculation(user:discord.User,channel?:discord.Channel|null,guild?:discord.Guild|null, settings?:ODPermissionSettings|null): Promise<ODPermissionResult> {
+        const idRegex = (settings && typeof settings.idRegex != "undefined") ? settings.idRegex : null
+        const allowGlobalUserScope = (settings && typeof settings.allowGlobalUserScope != "undefined") ? settings.allowGlobalUserScope : true
+        const allowGlobalRoleScope = (settings && typeof settings.allowGlobalRoleScope != "undefined") ? settings.allowGlobalRoleScope : true
+
+        //check for global user permissions
+        if (allowGlobalUserScope){
+            const users = this.getFiltered((permission) => (!idRegex || (idRegex && idRegex.test(permission.id.value))) && permission.scope == "global-user" && (permission.value instanceof discord.User) && permission.value.id == user.id)
+
+            if (users.length > 0){
+                //sort all permisions from highest to lowest
+                users.sort((a,b) => {
+                    const levelA = ODPermissionLevel[a.permission]
+                    const levelB = ODPermissionLevel[b.permission]
+
+                    if (levelB > levelA) return 1
+                    else if (levelA > levelB) return -1
+                    else return 0
+                })
+
+                return {
+                    type:users[0].permission,
+                    scope:"global-user",
+                    level:ODPermissionLevel[users[0].permission],
+                    source:users[0] ?? null
+                }
+            }
+        }
+            
+        //check for global role permissions
+        if (allowGlobalRoleScope){
+            if (guild){
+                const member = await this.#client.fetchGuildMember(guild,user.id)
+                if (member){
+                    const memberRoles = member.roles.cache.map((role) => role.id)
+                    const roles = this.getFiltered((permission) => (!idRegex || (idRegex && idRegex.test(permission.id.value))) && permission.scope == "global-role" && (permission.value instanceof discord.Role) && memberRoles.includes(permission.value.id) && permission.value.guild.id == guild.id)
+
+                    if (roles.length > 0){
+                        //sort all permisions from highest to lowest
+                        roles.sort((a,b) => {
+                            const levelA = ODPermissionLevel[a.permission]
+                            const levelB = ODPermissionLevel[b.permission]
+        
+                            if (levelB > levelA) return 1
+                            else if (levelA > levelB) return -1
+                            else return 0
+                        })
+        
+                        return {
+                            type:roles[0].permission,
+                            scope:"global-role",
+                            level:ODPermissionLevel[roles[0].permission],
+                            source:roles[0] ?? null
+                        }
+                    }
+                }
+            }
+        }
+
+        //spread result to prevent accidental referencing
+        return {...this.defaultResult}
+    }
+    /**Check for channel permissions. Result will be compared with the global perms in `#defaultCalculation()`. */
+    async #defaultChannelCalculation(user:discord.User,channel?:discord.Channel|null,guild?:discord.Guild|null, settings?:ODPermissionSettings|null): Promise<ODPermissionResult> {
+        const idRegex = (settings && typeof settings.idRegex != "undefined") ? settings.idRegex : null
+        const allowChannelUserScope = (settings && typeof settings.allowChannelUserScope != "undefined") ? settings.allowChannelUserScope : true
+        const allowChannelRoleScope = (settings && typeof settings.allowChannelRoleScope != "undefined") ? settings.allowChannelRoleScope : true
+        
+        if (guild && channel && !channel.isDMBased()){
+            //check for channel user permissions
+            if (allowChannelUserScope){
+                const users = this.getFiltered((permission) => (!idRegex || (idRegex && idRegex.test(permission.id.value))) && permission.scope == "channel-user" && permission.channel && (permission.channel.id == channel.id) && (permission.value instanceof discord.User) && permission.value.id == user.id)
+
+                if (users.length > 0){
+                    //sort all permisions from highest to lowest
+                    users.sort((a,b) => {
+                        const levelA = ODPermissionLevel[a.permission]
+                        const levelB = ODPermissionLevel[b.permission]
+
+                        if (levelB > levelA) return 1
+                        else if (levelA > levelB) return -1
+                        else return 0
+                    })
+
+                    return {
+                        type:users[0].permission,
+                        scope:"channel-user",
+                        level:ODPermissionLevel[users[0].permission],
+                        source:users[0] ?? null
+                    }
+                }
+            }
+            
+            //check for channel role permissions
+            if (allowChannelRoleScope){
+                const member = await this.#client.fetchGuildMember(guild,user.id)
+                if (member){
+                    const memberRoles = member.roles.cache.map((role) => role.id)
+                    const roles = this.getFiltered((permission) => (!idRegex || (idRegex && idRegex.test(permission.id.value))) && permission.scope == "channel-role" && permission.channel && (permission.channel.id == channel.id) && (permission.value instanceof discord.Role) && memberRoles.includes(permission.value.id) && permission.value.guild.id == guild.id)
+
+                    if (roles.length > 0){
+                        //sort all permisions from highest to lowest
+                        roles.sort((a,b) => {
+                            const levelA = ODPermissionLevel[a.permission]
+                            const levelB = ODPermissionLevel[b.permission]
+        
+                            if (levelB > levelA) return 1
+                            else if (levelA > levelB) return -1
+                            else return 0
+                        })
+        
+                        return {
+                            type:roles[0].permission,
+                            scope:"channel-role",
+                            level:ODPermissionLevel[roles[0].permission],
+                            source:roles[0] ?? null
+                        }
+                    }
+                }
+            }
+        }
+
+        //spread result to prevent accidental modification because of referencing
+        return {...this.defaultResult}
+    }
+
+    /**Check the permissions for a certain command of the bot. */
+    async checkCommandPerms(permissionMode:string,requiredLevel:ODPermissionType,user:discord.User,member?:discord.GuildMember|null,channel?:discord.Channel|null,guild?:discord.Guild|null,settings?:ODPermissionSettings): Promise<ODPermissionCommandResult> {
+        if (permissionMode === "none"){
+            return {hasPerms:false,reason:"disabled"}
+
+        }else if (permissionMode === "everyone"){
+            const isAdmin = this.hasPermissions(requiredLevel,await this.getPermissions(user,channel,guild,settings))
+            return {hasPerms:true,isAdmin}
+
+        }else if (permissionMode === "admin"){
+            const isAdmin = this.hasPermissions(requiredLevel,await this.getPermissions(user,channel,guild,settings))
+            if (!isAdmin) return {hasPerms:false,reason:"no-perms"}
+            else return {hasPerms:true,isAdmin}
+        }else{
+            if (!guild || !member){
+                this.#debug.debug("ODPermissionManager.checkCommandPerms(): Permission Error, Not in server! (#1)")
+                return {hasPerms:false,reason:"not-in-server"}
+            }
+            const role = await this.#client.fetchGuildRole(guild,permissionMode)
+            if (!role){
+                this.#debug.debug("ODPermissionManager.checkCommandPerms(): Permission Error, Not in server! (#2)")
+                return {hasPerms:false,reason:"not-in-server"}
+            }
+            if (!role.members.has(member.id)) return {hasPerms:false,reason:"no-perms"}
+
+            const isAdmin = this.hasPermissions(requiredLevel,await this.getPermissions(user,channel,guild,settings))
+            return {hasPerms:true,isAdmin}
+        }
+    }
+}

package/src/api/modules/plugin.ts

@@ -0,0 +1,242 @@
+///////////////////////////////////////
+//PLUGIN MODULE
+///////////////////////////////////////
+import { ODId, ODManager, ODManagerData, ODValidId, ODVersion } from "./base"
+import { ODDebugger } from "./console"
+import nodepath from "path"
+
+/**## ODUnknownCrashedPlugin `interface`
+ * Basic details for a plugin that crashed while loading the `plugin.json` file.
+ */
+export interface ODUnknownCrashedPlugin {
+    /**The name of the plugin. (path when plugin crashed before `name` was loaded) */
+    name:string,
+    /**The description of the plugin. (when found before crashing) */
+    description:string
+}
+
+/**## ODPluginManager `class`
+ * This is an Open Discord plugin manager.
+ * 
+ * It manages all active plugins in the bot!
+ * It also contains all "plugin classes" which are managers registered by plugins.
+ * These are accessible via the `opendiscord.plugins.classes` global.
+ * 
+ * Use `isPluginLoaded()` to check if a plugin has been loaded. 
+ */
+export class ODPluginManager extends ODManager<ODPlugin> {
+    /**A manager for all custom managers registered by plugins. */
+    classes: ODPluginClassManager
+    /**A list of basic details from all plugins that crashed while loading the `plugin.json` file. */
+    unknownCrashedPlugins: ODUnknownCrashedPlugin[] = []
+    
+    constructor(debug:ODDebugger){
+        super(debug,"plugin")
+        this.classes = new ODPluginClassManager(debug)
+    }
+
+    /**Check if a plugin has been loaded successfully and is available for usage.*/
+    isPluginLoaded(id:ODValidId): boolean {
+        const newId = new ODId(id)
+        const plugin = this.get(newId)
+        return (plugin !== null && plugin.executed)
+    }
+}
+
+/**## ODPluginData `interface`
+ * Parsed data from the `plugin.json` file in a plugin.
+ */
+export interface ODPluginData {
+    /**The name of this plugin (shown on startup) */
+    name:string,
+    /**The id of this plugin. (Must be identical to directory name) */
+    id:string,
+    /**The version of this plugin. */
+    version:string,
+    /**The location of the start file of the plugin relative to the rootDir of the plugin */
+    startFile:string,
+    /**A list of compatible versions. (e.g. `["OTv4.0.x", "OMv1.x.x"]`) (optional, will be required in future version)
+     * - `OT` --> Open Ticket support
+     * - `OM` --> Open Moderation support
+     */
+    supportedVersions?:string[],
+
+    /**Is this plugin enabled? */
+    enabled:boolean,
+    /**The priority of this plugin. Higher priority will load before lower priority. */
+    priority:number,
+    /**A list of events to register to the `opendiscord.events` global before loading any plugins. This way, plugins with a higher priority are able to use events from this plugin as well! */
+    events:string[]
+
+    /**Npm dependencies which are required for this plugin to work. */
+    npmDependencies:string[],
+    /**Plugins which are required for this plugin to work. */
+    requiredPlugins:string[],
+    /**Plugins which are incompatible with this plugin. */
+    incompatiblePlugins:string[],
+
+    /**Additional details about this plugin. */
+    details:ODPluginDetails
+}
+
+/**## ODPluginDetails `interface`
+ * Additional details in the `plugin.json` file from a plugin.
+ */
+export interface ODPluginDetails {
+    /**The main author of the plugin. Additional contributors can be specified in `contributors`. */
+    author:string,
+    /**A list of plugin contributors. (optional, will be required in future version) */
+    contributors?:string[],
+    /**A short description of this plugin. */
+    shortDescription:string,
+    /**A large description of this plugin. */
+    longDescription:string,
+    /**A URL to a cover image of this plugin. (currently unused) */
+    imageUrl:string,
+    /**A URL to the website/project page of this plugin. (currently unused) */
+    projectUrl:string,
+    /**A list of tags/categories that this plugin affects. */
+    tags:string[]
+}
+
+/**## ODPlugin `class`
+ * This is an Open Discord plugin.
+ * 
+ * It represents a single plugin in the `./plugins/` directory.
+ * All plugins are accessible via the `opendiscord.plugins` global.
+ * 
+ * Don't re-execute plugins which are already enabled! It might break the bot or plugin. 
+ */
+export class ODPlugin extends ODManagerData {
+    /**The name of the directory of this plugin. (same as id) */
+    dir: string
+    /**All plugin data found in the `plugin.json` file. */
+    data: ODPluginData
+    /**The name of this plugin. */
+    name: string
+    /**The priority of this plugin. */
+    priority: number
+    /**The version of this plugin. */
+    version: ODVersion
+    /**The additional details of this plugin. */
+    details: ODPluginDetails
+
+    /**Is this plugin enabled? */
+    enabled: boolean
+    /**Did this plugin execute successfully?. */
+    executed: boolean
+    /**Did this plugin crash? (A reason is available in the `crashReason`) */
+    crashed: boolean
+    /**The reason which caused this plugin to crash. */
+    crashReason: null|"incompatible.plugin"|"missing.plugin"|"missing.dependency"|"incompatible.version"|"executed" = null
+    
+    constructor(dir:string, jsondata:ODPluginData){
+        super(jsondata.id)
+        this.dir = dir
+        this.data = jsondata
+        this.name = jsondata.name
+        this.priority = jsondata.priority
+        this.version = ODVersion.fromString("plugin",jsondata.version)
+        this.details = jsondata.details
+
+        this.enabled = jsondata.enabled
+        this.executed = false
+        this.crashed = false
+    }
+
+    /**Get the startfile location relative to the `./plugins/` directory. (`./dist/plugins/`) when compiled) */
+    getStartFile(){
+        const newFile = this.data.startFile.replace(/\.ts$/,".js")
+        return nodepath.join(this.dir,newFile)
+    }
+    /**Execute this plugin. Returns `false` on crash. */
+    async execute(debug:ODDebugger,force?:boolean): Promise<boolean> {
+        if ((this.enabled && !this.crashed) || force){
+            try{
+                //import relative plugin directory path (works on windows & unix based systems)
+                const pluginPath = nodepath.join("../../../../plugins/",this.getStartFile()).replaceAll("\\","/")
+                await import(pluginPath)
+                debug.console.log("Plugin \""+this.id.value+"\" loaded successfully!","plugin")
+                this.executed = true
+                return true
+            }catch(error){
+                this.crashed = true
+                this.crashReason = "executed"
+
+                debug.console.log(error.message+", canceling plugin execution...","plugin",[
+                    {key:"path",value:"./plugins/"+this.dir}
+                ])
+                debug.console.log("You can see more about this error in the ./debug.txt file!","info")
+                debug.console.debugfile.writeText(error.stack)
+
+                return false
+            }
+        }else return true
+    }
+
+    /**Check if a npm dependency exists. */
+    #checkDependency(id:string){
+        try{
+            require.resolve(id)
+            return true
+        }catch{
+            return false
+        }
+    }
+
+    /**Get a list of all missing npm dependencies that are required for this plugin. */
+    dependenciesInstalled(){
+        const missing: string[] = []
+        this.data.npmDependencies.forEach((d) => {
+            if (!this.#checkDependency(d)){
+                missing.push(d)
+            }
+        })
+        
+        return missing
+    }
+    /**Get a list of all missing plugins that are required for this plugin. */
+    pluginsInstalled(manager:ODPluginManager){
+        const missing: string[] = []
+        this.data.requiredPlugins.forEach((p) => {
+            const plugin = manager.get(p)
+            if (!plugin || !plugin.enabled){
+                missing.push(p)
+            }
+        })
+        
+        return missing
+    }
+    /**Get a list of all enabled incompatible plugins that interfere with this plugin. */
+    pluginsIncompatible(manager:ODPluginManager){
+        const incompatible: string[] = []
+        this.data.incompatiblePlugins.forEach((p) => {
+            const plugin = manager.get(p)
+            if (plugin && plugin.enabled){
+                incompatible.push(p)
+            }
+        })
+        
+        return incompatible
+    }
+    /**Get a list of all authors & contributors of this plugin. */
+    getAuthors(): string[] {
+        return [this.details.author,...(this.details.contributors ?? [])]
+    }
+}
+
+/**## ODPluginClassManager `class`
+ * This is an Open Discord plugin class manager.
+ * 
+ * It manages all managers registered by plugins!
+ * Plugins are able to register their own managers, handlers, functions, classes, ... here.
+ * By doing this, other plugins are also able to make use of it.
+ * This can be useful for plugins that want to extend other plugins.
+ * 
+ * Use `isPluginLoaded()` to check if a plugin has been loaded before trying to access the manager.
+ */
+export class ODPluginClassManager extends ODManager<ODManagerData> {
+    constructor(debug:ODDebugger){
+        super(debug,"plugin class")
+    }
+}

package/src/api/modules/post.ts

@@ -0,0 +1,90 @@
+///////////////////////////////////////
+//POST MODULE
+///////////////////////////////////////
+import { ODId, ODManager, ODManagerData, ODValidId } from "./base"
+import { ODMessageBuildResult, ODMessageBuildSentResult } from "./builder"
+import { ODDebugger } from "./console"
+import * as discord from "discord.js"
+
+/**## ODPostManager `class`
+ * This is an Open Discord post manager.
+ * 
+ * It manages `ODPosts`'s for you.
+ * 
+ * You can use this to get the logs channel of the bot (or some other static channel/category).
+ */
+export class ODPostManager extends ODManager<ODPost<discord.GuildBasedChannel>> {
+    /**A reference to the main server of the bot */
+    #guild: discord.Guild|null = null
+
+    constructor(debug:ODDebugger){
+        super(debug,"post")
+    }
+
+    add(data:ODPost<discord.GuildBasedChannel>, overwrite?:boolean): boolean {
+        if (this.#guild) data.useGuild(this.#guild)
+        return super.add(data,overwrite)
+    }
+    /**Initialize the post manager & all posts. */
+    async init(guild:discord.Guild){
+        this.#guild = guild
+        for (const post of this.getAll()){
+            post.useGuild(guild)
+            await post.init()
+        }
+    }
+}
+
+/**## ODPost `class`
+ * This is an Open Discord post class.
+ * 
+ * A post is just a shortcut to a static discord channel or category.
+ * This can be used to get a specific channel over and over again!
+ * 
+ * This class also contains utilities for sending messages via the Open Discord builders.
+ */
+export class ODPost<ChannelType extends discord.GuildBasedChannel> extends ODManagerData {
+    /**A reference to the main server of the bot */
+    #guild: discord.Guild|null = null
+    /**Is this post already initialized? */
+    ready: boolean = false
+    /**The discord.js channel */
+    channel: ChannelType|null = null
+    /**The discord channel id */
+    channelId: string
+    
+    constructor(id:ODValidId, channelId:string){
+        super(id)
+        this.channelId = channelId
+    }
+
+    /**Use a specific guild in this class for fetching the channel*/
+    useGuild(guild:discord.Guild|null){
+        this.#guild = guild
+    }
+    /**Change the channel id to another channel! */
+    setChannelId(id:string){
+        this.channelId = id
+    }
+    /**Initialize the discord.js channel of this post. */
+    async init(){
+        if (this.ready) return
+        if (!this.#guild) return this.channel = null
+        try{
+            this.channel = await this.#guild.channels.fetch(this.channelId) as ChannelType
+        }catch{
+            this.channel = null
+        }
+        this.ready = true
+    }
+    /**Send a message to this channel using the Open Discord builder system */
+    async send(msg:ODMessageBuildResult): Promise<ODMessageBuildSentResult<true>> {
+        if (!this.channel || !this.channel.isTextBased()) return {success:false,message:null}
+        try{
+            const sent = await this.channel.send(msg.message)
+            return {success:true,message:sent}
+        }catch{
+            return {success:false,message:null}
+        }
+    }
+}