@open-discord-bots/framework 0.0.1 → 0.0.2

package/dist/api/modules/database.js

@@ -0,0 +1,271 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ODFormattedJsonDatabase = exports.ODJsonDatabase = exports.ODDatabase = exports.ODDatabaseManager = void 0;
+///////////////////////////////////////
+//DATABASE MODULE
+///////////////////////////////////////
+const base_1 = require("./base");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+/**## ODDatabaseManager `class`
+ * This is an Open Discord database manager.
+ *
+ * It manages all databases in the bot and allows to permanently store data from the bot!
+ *
+ * You can use this class to get/add a database (`ODDatabase`) in your plugin!
+ */
+class ODDatabaseManager extends base_1.ODManager {
+    constructor(debug) {
+        super(debug, "database");
+    }
+    /**Init all database files. */
+    async init() {
+        for (const database of this.getAll()) {
+            try {
+                await database.init();
+            }
+            catch (err) {
+                process.emit("uncaughtException", new base_1.ODSystemError(err));
+            }
+        }
+    }
+}
+exports.ODDatabaseManager = ODDatabaseManager;
+/**## ODDatabase `class`
+ * This is an Open Discord database template.
+ * This class doesn't do anything at all, it just gives a template & basic methods for a database. Use `ODJsonDatabase` instead!
+ *
+ * You can use this class if you want to create your own database implementation (e.g. `mongodb`, `mysql`,...)!
+ */
+class ODDatabase extends base_1.ODManagerData {
+    /**The name of the file with extension. */
+    file = "";
+    /**The path to the file relative to the main directory. */
+    path = "";
+    /**Init the database. */
+    init() {
+        //nothing
+    }
+    /**Add/Overwrite a specific category & key in the database. Returns `true` when overwritten. */
+    set(category, key, value) {
+        return false;
+    }
+    /**Get a specific category & key in the database */
+    get(category, key) {
+        return undefined;
+    }
+    /**Delete a specific category & key in the database */
+    delete(category, key) {
+        return false;
+    }
+    /**Check if a specific category & key exists in the database */
+    exists(category, key) {
+        return false;
+    }
+    /**Get a specific category in the database */
+    getCategory(category) {
+        return undefined;
+    }
+    /**Get all values in the database */
+    getAll() {
+        return [];
+    }
+}
+exports.ODDatabase = ODDatabase;
+/**## ODJsonDatabase `class`
+ * This is an Open Discord JSON database.
+ * It stores data in a `json` file as a large `Array` using the `category`, `key`, `value` strategy.
+ * You can store the following types: `string`, `number`, `boolean`, `array`, `object` & `null`!
+ *
+ * You can use this class if you want to add your own database or to use an existing one!
+ */
+class ODJsonDatabase extends ODDatabase {
+    constructor(id, file, customPath) {
+        super(id);
+        this.file = (file.endsWith(".json")) ? file : file + ".json";
+        this.path = customPath ? path_1.default.join("./", customPath, this.file) : path_1.default.join("./database/", this.file);
+    }
+    /**Init the database. */
+    init() {
+        this.#system.getData();
+    }
+    /**Set/overwrite the value of `category` & `key`. Returns `true` when overwritten!
+     * @example
+     * const didOverwrite = database.setData("category","key","value") //value can be any of the valid types
+     * //You need an ODJsonDatabase class named "database" for this example to work!
+     */
+    set(category, key, value) {
+        const currentList = this.#system.getData();
+        const currentData = currentList.find((d) => (d.category === category) && (d.key === key));
+        //overwrite when already present
+        if (currentData) {
+            currentList[currentList.indexOf(currentData)].value = value;
+        }
+        else {
+            currentList.push({ category, key, value });
+        }
+        this.#system.setData(currentList);
+        return currentData ? true : false;
+    }
+    /**Get the value of `category` & `key`. Returns `undefined` when non-existent!
+     * @example
+     * const data = database.getData("category","key") //data will be the value
+     * //You need an ODJsonDatabase class named "database" for this example to work!
+     */
+    get(category, key) {
+        const currentList = this.#system.getData();
+        const tempresult = currentList.find((d) => (d.category === category) && (d.key === key));
+        return tempresult ? tempresult.value : undefined;
+    }
+    /**Remove the value of `category` & `key`. Returns `undefined` when non-existent!
+     * @example
+     * const didExist = database.deleteData("category","key") //delete this value
+     * //You need an ODJsonDatabase class named "database" for this example to work!
+     */
+    delete(category, key) {
+        const currentList = this.#system.getData();
+        const currentData = currentList.find((d) => (d.category === category) && (d.key === key));
+        if (currentData)
+            currentList.splice(currentList.indexOf(currentData), 1);
+        this.#system.setData(currentList);
+        return currentData ? true : false;
+    }
+    /**Check if a value of `category` & `key` exists. Returns `false` when non-existent! */
+    exists(category, key) {
+        const currentList = this.#system.getData();
+        const tempresult = currentList.find((d) => (d.category === category) && (d.key === key));
+        return tempresult ? true : false;
+    }
+    /**Get all values in `category`. Returns `undefined` when non-existent! */
+    getCategory(category) {
+        const currentList = this.#system.getData();
+        const tempresult = currentList.filter((d) => (d.category === category));
+        return tempresult ? tempresult.map((data) => { return { key: data.key, value: data.value }; }) : undefined;
+    }
+    /**Get all values in `category`. */
+    getAll() {
+        return this.#system.getData();
+    }
+    #system = {
+        /**Read parsed data from the json file */
+        getData: () => {
+            if (fs_1.default.existsSync(this.path)) {
+                try {
+                    return JSON.parse(fs_1.default.readFileSync(this.path).toString());
+                }
+                catch (err) {
+                    process.emit("uncaughtException", err);
+                    throw new base_1.ODSystemError("Unable to read database " + this.path + "! getData() read error. (see error above)");
+                }
+            }
+            else {
+                fs_1.default.writeFileSync(this.path, "[]");
+                return [];
+            }
+        },
+        /**Write parsed data to the json file */
+        setData: (data) => {
+            fs_1.default.writeFileSync(this.path, JSON.stringify(data, null, "\t"));
+        }
+    };
+}
+exports.ODJsonDatabase = ODJsonDatabase;
+/**## ODFormattedJsonDatabase `class`
+ * This is an Open Discord Formatted JSON database.
+ * It stores data in a `json` file as a large `Array` using the `category`, `key`, `value` strategy.
+ * You can store the following types: `string`, `number`, `boolean`, `array`, `object` & `null`!
+ *
+ * This one is exactly the same as `ODJsonDatabase`, but it has a formatter from the `formatted-json-stringify` package.
+ * This can help you organise it a little bit better!
+ */
+class ODFormattedJsonDatabase extends ODDatabase {
+    /**The formatter to use on the database array */
+    formatter;
+    constructor(id, file, formatter, customPath) {
+        super(id);
+        this.file = (file.endsWith(".json")) ? file : file + ".json";
+        this.path = customPath ? path_1.default.join("./", customPath, this.file) : path_1.default.join("./database/", this.file);
+        this.formatter = formatter;
+    }
+    /**Init the database. */
+    init() {
+        this.#system.getData();
+    }
+    /**Set/overwrite the value of `category` & `key`. Returns `true` when overwritten!
+     * @example
+     * const didOverwrite = database.setData("category","key","value") //value can be any of the valid types
+     * //You need an ODFormattedJsonDatabase class named "database" for this example to work!
+     */
+    set(category, key, value) {
+        const currentList = this.#system.getData();
+        const currentData = currentList.find((d) => (d.category === category) && (d.key === key));
+        //overwrite when already present
+        if (currentData) {
+            currentList[currentList.indexOf(currentData)].value = value;
+        }
+        else {
+            currentList.push({ category, key, value });
+        }
+        this.#system.setData(currentList);
+        return currentData ? true : false;
+    }
+    /**Get the value of `category` & `key`. Returns `undefined` when non-existent!
+     * @example
+     * const data = database.getData("category","key") //data will be the value
+     * //You need an ODFormattedJsonDatabase class named "database" for this example to work!
+     */
+    get(category, key) {
+        const currentList = this.#system.getData();
+        const tempresult = currentList.find((d) => (d.category === category) && (d.key === key));
+        return tempresult ? tempresult.value : undefined;
+    }
+    /**Remove the value of `category` & `key`. Returns `undefined` when non-existent!
+     * @example
+     * const didExist = database.deleteData("category","key") //delete this value
+     * //You need an ODFormattedJsonDatabase class named "database" for this example to work!
+     */
+    delete(category, key) {
+        const currentList = this.#system.getData();
+        const currentData = currentList.find((d) => (d.category === category) && (d.key === key));
+        if (currentData)
+            currentList.splice(currentList.indexOf(currentData), 1);
+        this.#system.setData(currentList);
+        return currentData ? true : false;
+    }
+    /**Check if a value of `category` & `key` exists. Returns `false` when non-existent! */
+    exists(category, key) {
+        const currentList = this.#system.getData();
+        const tempresult = currentList.find((d) => (d.category === category) && (d.key === key));
+        return tempresult ? true : false;
+    }
+    /**Get all values in `category`. Returns `undefined` when non-existent! */
+    getCategory(category) {
+        const currentList = this.#system.getData();
+        const tempresult = currentList.filter((d) => (d.category === category));
+        return tempresult ? tempresult.map((data) => { return { key: data.key, value: data.value }; }) : undefined;
+    }
+    /**Get all values in `category`. */
+    getAll() {
+        return this.#system.getData();
+    }
+    #system = {
+        /**Read parsed data from the json file */
+        getData: () => {
+            if (fs_1.default.existsSync(this.path)) {
+                return JSON.parse(fs_1.default.readFileSync(this.path).toString());
+            }
+            else {
+                fs_1.default.writeFileSync(this.path, "[]");
+                return [];
+            }
+        },
+        /**Write parsed data to the json file */
+        setData: (data) => {
+            fs_1.default.writeFileSync(this.path, this.formatter.stringify(data));
+        }
+    };
+}
+exports.ODFormattedJsonDatabase = ODFormattedJsonDatabase;

package/dist/api/modules/event.d.ts

@@ -0,0 +1,43 @@
+import { ODManagerData, ODManager, ODValidId } from "./base";
+import { ODDebugger } from "./console";
+/**## ODEvent `class`
+ * This is an Open Discord event.
+ *
+ * This class is made to work with the `ODEventManager` to handle events.
+ * The function of this specific class is to manage all listeners for a specifc event!
+ */
+export declare class ODEvent extends ODManagerData {
+    #private;
+    /**The list of permanent listeners. */
+    listeners: Function[];
+    /**The list of one-time listeners. List is cleared every time the event is emitted. */
+    oncelisteners: Function[];
+    /**The max listener limit before a possible memory leak will be announced */
+    listenerLimit: number;
+    /**Use the Open Discord debugger in this manager for logs*/
+    useDebug(debug: ODDebugger | null): void;
+    /**Edit the listener limit */
+    setListenerLimit(limit: number): void;
+    /**Add a permanent callback to this event. This will stay as long as the bot is running! */
+    listen(callback: Function): void;
+    /**Add a one-time-only callback to this event. This will only trigger the callback once! */
+    listenOnce(callback: Function): void;
+    /**Wait until this event is fired! Be carefull with it, because it could block the entire bot when wrongly used! */
+    wait(): Promise<any[]>;
+    /**Emit this event to all listeners. You are required to provide all parameters of the event! */
+    emit(params: any[]): Promise<void>;
+}
+/**## ODEventManager `class`
+ * This is an Open Discord event manager.
+ *
+ * This class is made to manage all events in the bot. You can compare it with the built-in node.js `EventEmitter`
+ *
+ * It's not recommended to create this class yourself. Plugin events should be registered in their `plugin.json` file instead.
+ * All events are available in the `opendiscord.events` global!
+ */
+export declare class ODEventManager extends ODManager<ODEvent> {
+    #private;
+    constructor(debug: ODDebugger);
+    add(data: ODEvent, overwrite?: boolean): boolean;
+    remove(id: ODValidId): ODEvent | null;
+}

package/dist/api/modules/event.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ODEventManager = exports.ODEvent = void 0;
+///////////////////////////////////////
+//EVENT MODULE
+///////////////////////////////////////
+const base_1 = require("./base");
+const console_1 = require("./console");
+/**## ODEvent `class`
+ * This is an Open Discord event.
+ *
+ * This class is made to work with the `ODEventManager` to handle events.
+ * The function of this specific class is to manage all listeners for a specifc event!
+ */
+class ODEvent extends base_1.ODManagerData {
+    /**Alias to Open Discord debugger. */
+    #debug;
+    /**The list of permanent listeners. */
+    listeners = [];
+    /**The list of one-time listeners. List is cleared every time the event is emitted. */
+    oncelisteners = [];
+    /**The max listener limit before a possible memory leak will be announced */
+    listenerLimit = 25;
+    /**Use the Open Discord debugger in this manager for logs*/
+    useDebug(debug) {
+        this.#debug = debug ?? undefined;
+    }
+    /**Get a collection of listeners combined from both types. Also clears the one-time listeners array! */
+    #getCurrentListeners() {
+        const final = [];
+        this.oncelisteners.forEach((l) => final.push(l));
+        this.listeners.forEach((l) => final.push(l));
+        this.oncelisteners = [];
+        return final;
+    }
+    /**Edit the listener limit */
+    setListenerLimit(limit) {
+        this.listenerLimit = limit;
+    }
+    /**Add a permanent callback to this event. This will stay as long as the bot is running! */
+    listen(callback) {
+        this.listeners.push(callback);
+        if (this.listeners.length > this.listenerLimit) {
+            if (this.#debug)
+                this.#debug.console.log(new console_1.ODConsoleWarningMessage("Possible event memory leak detected!", [
+                    { key: "event", value: this.id.value },
+                    { key: "listeners", value: this.listeners.length.toString() }
+                ]));
+        }
+    }
+    /**Add a one-time-only callback to this event. This will only trigger the callback once! */
+    listenOnce(callback) {
+        this.oncelisteners.push(callback);
+    }
+    /**Wait until this event is fired! Be carefull with it, because it could block the entire bot when wrongly used! */
+    async wait() {
+        return new Promise((resolve, reject) => {
+            this.oncelisteners.push((...args) => { resolve(args); });
+        });
+    }
+    /**Emit this event to all listeners. You are required to provide all parameters of the event! */
+    async emit(params) {
+        for (const listener of this.#getCurrentListeners()) {
+            try {
+                await listener(...params);
+            }
+            catch (err) {
+                process.emit("uncaughtException", err);
+            }
+        }
+    }
+}
+exports.ODEvent = ODEvent;
+/**## ODEventManager `class`
+ * This is an Open Discord event manager.
+ *
+ * This class is made to manage all events in the bot. You can compare it with the built-in node.js `EventEmitter`
+ *
+ * It's not recommended to create this class yourself. Plugin events should be registered in their `plugin.json` file instead.
+ * All events are available in the `opendiscord.events` global!
+ */
+class ODEventManager extends base_1.ODManager {
+    /**Reference to the Open Discord debugger */
+    #debug;
+    constructor(debug) {
+        super(debug, "event");
+        this.#debug = debug;
+    }
+    add(data, overwrite) {
+        data.useDebug(this.#debug);
+        return super.add(data, overwrite);
+    }
+    remove(id) {
+        const data = super.remove(id);
+        if (data)
+            data.useDebug(null);
+        return data;
+    }
+}
+exports.ODEventManager = ODEventManager;

package/dist/api/modules/flag.d.ts

@@ -0,0 +1,40 @@
+import { ODValidId, ODManager, ODManagerData } from "./base";
+import { ODDebugger } from "./console";
+/**## ODFlag `class`
+ * This is an Open Discord flag.
+ *
+ * A flag is a boolean that can be specified by a parameter in the console.
+ * It's useful for small settings that are only required once in a while.
+ *
+ * Flags can also be enabled manually by plugins!
+ */
+export declare class ODFlag extends ODManagerData {
+    /**The method that has been used to set the value of this flag. (`null` when not set) */
+    method: "param" | "manual" | null;
+    /**The name of this flag. Visible to the user. */
+    name: string;
+    /**The description of this flag. Visible to the user. */
+    description: string;
+    /**The name of the parameter in the console. (e.g. `--test`) */
+    param: string;
+    /**A list of aliases for the parameter in the console. */
+    aliases: string[];
+    /**The value of this flag. */
+    value: boolean;
+    constructor(id: ODValidId, name: string, description: string, param: string, aliases?: string[], initialValue?: boolean);
+    /**Set the value of this flag. */
+    setValue(value: boolean, method?: "param" | "manual"): void;
+    /**Detect if the process contains the param or aliases & set the value. Use `force` to overwrite a manually set value. */
+    detectProcessParams(force?: boolean): void;
+}
+/**## ODFlagManager `class`
+ * This is an Open Discord flag manager.
+ *
+ * This class is responsible for managing & initiating all flags of the bot.
+ * It also contains a shortcut for initiating all flags.
+ */
+export declare class ODFlagManager extends ODManager<ODFlag> {
+    constructor(debug: ODDebugger);
+    /**Set all flags to their `process.argv` value. */
+    init(): Promise<void>;
+}

package/dist/api/modules/flag.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ODFlagManager = exports.ODFlag = void 0;
+///////////////////////////////////////
+//FLAG MODULE
+///////////////////////////////////////
+const base_1 = require("./base");
+/**## ODFlag `class`
+ * This is an Open Discord flag.
+ *
+ * A flag is a boolean that can be specified by a parameter in the console.
+ * It's useful for small settings that are only required once in a while.
+ *
+ * Flags can also be enabled manually by plugins!
+ */
+class ODFlag extends base_1.ODManagerData {
+    /**The method that has been used to set the value of this flag. (`null` when not set) */
+    method = null;
+    /**The name of this flag. Visible to the user. */
+    name;
+    /**The description of this flag. Visible to the user. */
+    description;
+    /**The name of the parameter in the console. (e.g. `--test`) */
+    param;
+    /**A list of aliases for the parameter in the console. */
+    aliases;
+    /**The value of this flag. */
+    value = false;
+    constructor(id, name, description, param, aliases, initialValue) {
+        super(id);
+        this.name = name;
+        this.description = description;
+        this.param = param;
+        this.aliases = aliases ?? [];
+        this.value = initialValue ?? false;
+    }
+    /**Set the value of this flag. */
+    setValue(value, method) {
+        this.value = value;
+        this.method = method ?? "manual";
+    }
+    /**Detect if the process contains the param or aliases & set the value. Use `force` to overwrite a manually set value. */
+    detectProcessParams(force) {
+        if (force) {
+            const params = [this.param, ...this.aliases];
+            this.setValue(params.some((p) => process.argv.includes(p)), "param");
+        }
+        else if (this.method != "manual") {
+            const params = [this.param, ...this.aliases];
+            this.setValue(params.some((p) => process.argv.includes(p)), "param");
+        }
+    }
+}
+exports.ODFlag = ODFlag;
+/**## ODFlagManager `class`
+ * This is an Open Discord flag manager.
+ *
+ * This class is responsible for managing & initiating all flags of the bot.
+ * It also contains a shortcut for initiating all flags.
+ */
+class ODFlagManager extends base_1.ODManager {
+    constructor(debug) {
+        super(debug, "flag");
+    }
+    /**Set all flags to their `process.argv` value. */
+    async init() {
+        await this.loopAll((flag) => {
+            flag.detectProcessParams(false);
+        });
+    }
+}
+exports.ODFlagManager = ODFlagManager;