zumito-framework 1.0.0

package/dist/ZumitoFramework.d.ts

@@ -0,0 +1,47 @@
+import { GuildMember, TextChannel } from "discord.js";
+import { Command } from "./types/Commands";
+import { FrameworkSettings } from "./types/FrameworkSettings";
+import { Module } from "./types/Module";
+import { FrameworkEvent } from "./types/FrameworkEvent";
+/**
+ * @class ZumitoFramework
+ * @classdesc The main class of the framework.
+ *
+ * @property {FrameworkSettings} settings - The settings of the framework.
+ * @property {Client} client - The client client instance.
+ * @property {Collection<string, Module>} modules - The modules loaded in the framework.
+ * @property {Collection<string, Command>} commands - The commands loaded in the framework.
+ */
+export declare class ZumitoFramework {
+    client: any;
+    settings: FrameworkSettings;
+    modules: Map<String, Module>;
+    commands: Map<String, Command>;
+    events: Map<String, FrameworkEvent>;
+    routes: any;
+    models: any;
+    database: any;
+    app: any;
+    /**
+     * @constructor
+     * @description Creates a new instance of the framework.
+     * @param {FrameworkSettings} settings - The settings of the framework.
+     * @example new ZumitoFramework({
+     *     prefix: '!',
+     *     discordClientOptions: {
+     *        token: 'token',
+     *        clientId: 'clientId',
+     *       intents: 0
+     *    }
+     * });
+     * @public
+     */
+    constructor(settings: FrameworkSettings);
+    startApiServer(): void;
+    private registerModules;
+    private registerModule;
+    private initializeDiscordClient;
+    private commandHandler;
+    static splitCommandLine(commandLine: any): any;
+    memberHasPermission(member: GuildMember, channel: TextChannel, permission: bigint): Promise<boolean>;
+}

package/dist/ZumitoFramework.js

@@ -0,0 +1,278 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZumitoFramework = void 0;
+const discord_js_1 = require("discord.js");
+const Module_1 = require("./types/Module");
+const express_1 = require("express");
+const ApiResponse_1 = require("./definitions/ApiResponse");
+const fs = require('fs');
+const path = require('path');
+const { Collection, Client } = require('discord.js');
+require('better-logging')(console);
+const { REST } = require('@discordjs/rest');
+const { Routes } = require('discord-api-types/v9');
+var mongoose = require("mongoose");
+var cookieParser = require("cookie-parser");
+var cors = require("cors");
+var http = require('http');
+/**
+ * @class ZumitoFramework
+ * @classdesc The main class of the framework.
+ *
+ * @property {FrameworkSettings} settings - The settings of the framework.
+ * @property {Client} client - The client client instance.
+ * @property {Collection<string, Module>} modules - The modules loaded in the framework.
+ * @property {Collection<string, Command>} commands - The commands loaded in the framework.
+ */
+class ZumitoFramework {
+    client;
+    settings;
+    modules;
+    commands;
+    events = new Map();
+    routes;
+    models;
+    database;
+    app;
+    /**
+     * @constructor
+     * @description Creates a new instance of the framework.
+     * @param {FrameworkSettings} settings - The settings of the framework.
+     * @example new ZumitoFramework({
+     *     prefix: '!',
+     *     discordClientOptions: {
+     *        token: 'token',
+     *        clientId: 'clientId',
+     *       intents: 0
+     *    }
+     * });
+     * @public
+     */
+    constructor(settings) {
+        this.settings = settings;
+        this.modules = new Map();
+        this.commands = new Map();
+        mongoose.connect(settings.mongoQueryString, { useNewUrlParser: true, useUnifiedTopology: true }).then(() => {
+            console.log('[✅] DB connection successful');
+        }).catch(err => {
+            console.error("Database connection error:", err.message);
+            process.exit(1);
+        });
+        this.database = mongoose.connection;
+        this.startApiServer();
+        this.registerModules();
+        this.initializeDiscordClient();
+        this.commandHandler();
+    }
+    startApiServer() {
+        this.app = (0, express_1.express)();
+        let port = process.env.PORT || '80';
+        this.app.set('port', port);
+        var server = http.createServer(this.app);
+        server.listen(port);
+        server.on('error', (err) => {
+            console.log('[❎] Error starting API web server: ' + err);
+        });
+        server.on('listening', () => {
+            console.log('[✅] API web server listening on port ' + port);
+        });
+        this.app.use(express_1.express.json());
+        this.app.use(express_1.express.urlencoded({ extended: false }));
+        this.app.use(cookieParser());
+        //this.app.use(express.static(path.join(__dirname, "public")));
+        //To allow cross-origin requests
+        this.app.use(cors());
+        //Route Prefixes
+        //this.app.use("/", indexRouter);
+        //this.app.use("/api/", apiRouter);
+        // throw 404 if URL not found
+        this.app.all("*", function (req, res) {
+            return ApiResponse_1.ApiResponse.notFoundResponse(res, "Page not found");
+        });
+        this.app.use(function (err, req, res) {
+            if (err.name === 'UnauthorizedError') {
+                return ApiResponse_1.ApiResponse.unauthorizedResponse(res, "Invalid token");
+            }
+        });
+    }
+    registerModules() {
+        let modulesFolder;
+        if (fs.existsSync(`${process.cwd()}/modules`)) {
+            modulesFolder = `${process.cwd()}/modules`;
+        }
+        else if (fs.existsSync(`${process.cwd()}/src/modules`)) {
+            modulesFolder = `${process.cwd()}/src/modules`;
+        }
+        else
+            return;
+        this.registerModule(__dirname, 'baseModule');
+        fs.readdirSync(modulesFolder).forEach(file => {
+            this.registerModule(modulesFolder, file);
+        });
+    }
+    registerModule(modulesFolder, moduleName) {
+        // Import module
+        let module;
+        if (fs.existsSync(path.join(modulesFolder, moduleName, 'index.js'))) {
+            module = require(path.join(modulesFolder, moduleName, 'index.js'));
+            module = Object.values(module)[0];
+        }
+        else if (fs.existsSync(path.join(modulesFolder, moduleName, 'index.ts'))) {
+            module = require(path.join(modulesFolder, moduleName, 'index.ts'));
+            module = Object.values(module)[0];
+        }
+        else {
+            module = Module_1.Module;
+        }
+        ;
+        // Create module instance
+        let moduleInstance = new module(path.join(modulesFolder, moduleName));
+        this.modules.set(moduleInstance.constructor.name, moduleInstance);
+        // Register module commands
+        this.commands = new Map([...this.commands, ...moduleInstance.getCommands()]);
+        // Register module events
+        this.events = new Map([...this.events, ...moduleInstance.getEvents()]);
+        /*
+
+        // Register module routes
+        this.routes = new Map([...this.routes, ...moduleInstance.getRoutes()]);
+
+        // Register module models
+        this.models = new Map([...this.models, ...moduleInstance.getModels()]);
+
+        */
+    }
+    initializeDiscordClient() {
+        this.client = new Client({
+            intents: this.settings.discordClientOptions.intents
+        });
+        this.client.login(this.settings.discordClientOptions.token);
+    }
+    commandHandler() {
+        this.client.on('messageCreate', async (message) => {
+            let channel = message.channel;
+            let prefix = this.settings.defaultPrefix;
+            const args = ZumitoFramework.splitCommandLine(message.content.slice(prefix.length));
+            const command = args.shift().toLowerCase();
+            let commandInstance;
+            if (message.content.startsWith(prefix)) {
+                if (!this.commands.has(command)) {
+                    let commandNames = Array.from(this.commands.keys());
+                    var autocorrect = require('autocorrect')({ words: commandNames });
+                    var correctedCommand = autocorrect(command);
+                    if (this.commands.has(correctedCommand)) {
+                        commandInstance = this.commands.get(correctedCommand);
+                    }
+                    else {
+                        return; // Command not found
+                    }
+                }
+                else {
+                    commandInstance = this.commands.get(command);
+                }
+                if (message.guild == null && commandInstance.dm == false)
+                    return;
+                if (commandInstance.adminOnly || commandInstance.permissions.length > 0) {
+                    let denied = false;
+                    if (this.memberHasPermission(message.member, message.channel, discord_js_1.PermissionsBitField.Flags.Administrator) || message.member.id != message.guild.ownerId) {
+                        if (commandInstance.permissions.length > 0) {
+                            commandInstance.permissions.forEach(permission => {
+                                if (!this.memberHasPermission(message.member, message.channel, permission)) {
+                                    denied = true;
+                                }
+                            });
+                        }
+                    }
+                    if (denied) {
+                        return message.reply({
+                            content: 'You do not have permission to use this command.',
+                            allowedMentions: {
+                                repliedUser: false,
+                            }
+                        });
+                    }
+                }
+                if (message.channel.isTextBased) {
+                    let channel = message.channel;
+                    // Check command is nsfw and if channel is allowed
+                    if (commandInstance.nsfw && !channel.nsfw && !channel.permissionsFor(message.member).has(discord_js_1.PermissionsBitField.Flags.Administrator) && message.member.id != message.guild.ownerId) {
+                        return message.reply({
+                            content: 'This command is nsfw and this channel is not nsfw.',
+                            allowedMentions: {
+                                repliedUser: false,
+                            }
+                        });
+                    }
+                }
+                try {
+                    let parsedArgs = new Map();
+                    args.forEach(function (arg, index) {
+                        parsedArgs.set(commandInstance.args?.[index]?.name || index, {
+                            name: commandInstance.args?.[index]?.name || index,
+                            value: arg
+                        });
+                    });
+                    await commandInstance.execute({
+                        message,
+                        args: parsedArgs,
+                        client: this.client,
+                    });
+                    if (!message.channel.isDMBased && !message.deletable && (false)) { // false = settings.deleteCommands
+                        try {
+                            message.delete().catch(function () {
+                                console.error('can\'t delete user command');
+                            });
+                            const metadata = await fetch('https://tulipo.ga/api/last_command/' + command).then(res => res.json());
+                        }
+                        catch (err) {
+                            console.error(err.name, err.message);
+                        }
+                    }
+                }
+                catch (error) {
+                    // let content = await getErrorEmbed({
+                    //     name: error.name,
+                    //     message: error.message,
+                    //     comid: com,
+                    //     args: args,
+                    //     stack: error.stack,
+                    // }, true);
+                    // try {
+                    //     message.reply(content);
+                    // } catch (e) {
+                    //     channel.send(content);
+                    // }
+                }
+            }
+        });
+    }
+    static splitCommandLine(commandLine) {
+        //log( 'commandLine', commandLine ) ;
+        //  Find a unique marker for the space character.
+        //  Start with '<SP>' and repeatedly append '@' if necessary to make it unique.
+        var spaceMarker = '<SP>';
+        while (commandLine.indexOf(spaceMarker) > -1)
+            spaceMarker += '@';
+        //  Protect double-quoted strings.
+        //   o  Find strings of non-double-quotes, wrapped in double-quotes.
+        //   o  The final double-quote is optional to allow for an unterminated string.
+        //   o  Replace each double-quoted-string with what's inside the qouble-quotes,
+        //      after each space character has been replaced with the space-marker above.
+        //   o  The outer double-quotes will not be present.
+        var noSpacesInQuotes = commandLine.replace(/"([^"]*)"?/g, (fullMatch, capture) => {
+            return capture.replace(/ /g, spaceMarker);
+        });
+        //  Now that it is safe to do so, split the command-line at one-or-more spaces.
+        var mangledParamArray = noSpacesInQuotes.split(/ +/);
+        //  Create a new array by restoring spaces from any space-markers.
+        var paramArray = mangledParamArray.map((mangledParam) => {
+            return mangledParam.replace(RegExp(spaceMarker, 'g'), ' ');
+        });
+        return paramArray;
+    }
+    async memberHasPermission(member, channel, permission) {
+        let memberPermission = await channel.permissionsFor(member);
+        return memberPermission.has(permission);
+    }
+}
+exports.ZumitoFramework = ZumitoFramework;

package/dist/baseModule/events/discord/interactionCreate.d.ts

@@ -0,0 +1,6 @@
+import { EventParameters } from "../../../types/EventParameters";
+import { FrameworkEvent } from "../../../types/FrameworkEvent";
+export declare abstract class InteractionCreate extends FrameworkEvent {
+    once: boolean;
+    execute({ interaction, client, framework }: EventParameters): Promise<void>;
+}

package/dist/baseModule/events/discord/interactionCreate.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InteractionCreate = void 0;
+const CommandType_1 = require("../../../types/CommandType");
+const FrameworkEvent_1 = require("../../../types/FrameworkEvent");
+class InteractionCreate extends FrameworkEvent_1.FrameworkEvent {
+    once = false;
+    async execute({ interaction, client, framework }) {
+        if (interaction.isCommand()) {
+            if (!framework.commands.has(interaction.commandName))
+                return;
+            const commandInstance = framework.commands.get(interaction.commandName);
+            let args = new Map();
+            commandInstance.args.forEach(arg => {
+                let option = interaction.options.get(arg.name);
+                if (option) {
+                    args.set(arg.name, option.value || option.user || option.role || option.channel || option.options || option.message || option.member || option.focused || option.autocomplete || option.attachment);
+                }
+            });
+            if (![CommandType_1.CommandType.any, CommandType_1.CommandType.separated, CommandType_1.CommandType.slash].includes(commandInstance.type))
+                return;
+            if (commandInstance.type === CommandType_1.CommandType.separated || commandInstance.type === CommandType_1.CommandType.slash) {
+                await commandInstance.executeSlashCommand({ client, interaction, args });
+            }
+            else {
+                await commandInstance.execute({ client, interaction, args });
+            }
+        }
+        else if (interaction.isButton()) {
+        }
+        else if (interaction.isSelectMenu()) {
+            let path = interaction.customId.split('.');
+            const command = framework.commands.get(path[0]);
+            if (command.selectMenu) {
+                command.selectMenu({ path, interaction, client, framework });
+            }
+        }
+    }
+}
+exports.InteractionCreate = InteractionCreate;

package/dist/definitions/ApiResponse.d.ts

@@ -0,0 +1,4 @@
+export declare class ApiResponse {
+    static notFoundResponse(res: any, msg: any): any;
+    static unauthorizedResponse(res: any, msg: any): any;
+}

package/dist/definitions/ApiResponse.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiResponse = void 0;
+class ApiResponse {
+    static notFoundResponse(res, msg) {
+        let data = {
+            message: msg,
+        };
+        return res.status(404).json(data);
+    }
+    ;
+    static unauthorizedResponse(res, msg) {
+        let data = {
+            message: msg,
+        };
+        return res.status(401).json(data);
+    }
+    ;
+}
+exports.ApiResponse = ApiResponse;

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { ZumitoFramework } from './ZumitoFramework';
+export { FrameworkSettings } from './types/FrameworkSettings';
+export { Command } from './types/Commands';
+export { Module } from './types/Module';
+export { CommandParameters } from './types/CommandParameters';
+export { CommandArguments } from './types/CommandArguments';

package/dist/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandArguments = exports.Module = exports.Command = exports.ZumitoFramework = void 0;
+var ZumitoFramework_1 = require("./ZumitoFramework");
+Object.defineProperty(exports, "ZumitoFramework", { enumerable: true, get: function () { return ZumitoFramework_1.ZumitoFramework; } });
+var Commands_1 = require("./types/Commands");
+Object.defineProperty(exports, "Command", { enumerable: true, get: function () { return Commands_1.Command; } });
+var Module_1 = require("./types/Module");
+Object.defineProperty(exports, "Module", { enumerable: true, get: function () { return Module_1.Module; } });
+var CommandArguments_1 = require("./types/CommandArguments");
+Object.defineProperty(exports, "CommandArguments", { enumerable: true, get: function () { return CommandArguments_1.CommandArguments; } });

package/dist/types/CommandArgDefinition.d.ts

@@ -0,0 +1,4 @@
+interface CommandArgDefinition {
+    name: string;
+    optional: boolean;
+}

package/dist/types/CommandArguments.d.ts

@@ -0,0 +1,8 @@
+import { CommandInteraction } from "discord.js";
+export declare class CommandArguments {
+    args: any;
+    constructor(args?: {});
+    get(key: any): any;
+    add(key: any, value: any): void;
+    static parseFromInteraction(interaction: CommandInteraction): CommandArguments;
+}

package/dist/types/CommandArguments.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandArguments = void 0;
+class CommandArguments {
+    args = {};
+    constructor(args = {}) {
+        this.args = args;
+    }
+    get(key) {
+        return this.args[key];
+    }
+    add(key, value) {
+        this.args[key] = value;
+    }
+    static parseFromInteraction(interaction) {
+        return new CommandArguments(interaction.options);
+    }
+}
+exports.CommandArguments = CommandArguments;

package/dist/types/CommandParameters.d.ts

@@ -0,0 +1,15 @@
+import { Client, Interaction, Message } from "discord.js";
+/**
+ * @class CommandParameters
+ * @classdesc Parameters passed to a command execution.
+ * @property {Client} client - The client client instance.
+ * @property {Message} message - The message that triggered the command.
+ * @property {interaction} interaction - The interaction that triggered the command.
+ * @property {args} args - The arguments passed to the command.
+ */
+export interface CommandParameters {
+    message?: Message;
+    interaction?: Interaction;
+    args: Map<String, any>;
+    client: Client;
+}

package/dist/types/CommandParameters.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/CommandType.d.ts

@@ -0,0 +1,6 @@
+export declare const CommandType: {
+    prefix: string;
+    slash: string;
+    separated: string;
+    any: string;
+};

package/dist/types/CommandType.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandType = void 0;
+exports.CommandType = {
+    prefix: 'prefix',
+    slash: 'slash',
+    separated: 'separated',
+    any: 'any',
+};

package/dist/types/Commands.d.ts

@@ -0,0 +1,23 @@
+import { CommandParameters } from "./CommandParameters";
+import { SelectMenuParameters } from "./SelectMenuParameters";
+export declare abstract class Command {
+    name: string;
+    categories: string[];
+    aliases?: string[];
+    examples?: string[];
+    permissions?: bigint[];
+    botPermissions?: string[];
+    hidden?: boolean;
+    adminOnly?: boolean;
+    nsfw?: boolean;
+    cooldown?: number;
+    slashCommand?: boolean;
+    dm: boolean;
+    args: CommandArgDefinition[];
+    type: string;
+    constructor();
+    abstract execute({ message, interaction, args, client }: CommandParameters): void;
+    executePrefixCommand({ message, interaction, args, client }: CommandParameters): void;
+    executeSlashCommand({ message, interaction, args, client }: CommandParameters): void;
+    selectMenu({ path, interaction, client, framework }: SelectMenuParameters): void;
+}

package/dist/types/Commands.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Command = void 0;
+const CommandType_1 = require("./CommandType");
+class Command {
+    name = this.constructor.name.toLowerCase();
+    categories = [];
+    aliases = [];
+    examples = [];
+    permissions = [];
+    botPermissions = [];
+    hidden = false;
+    adminOnly = false;
+    nsfw = false;
+    cooldown = 0;
+    slashCommand = false;
+    dm = false;
+    args = [];
+    type = CommandType_1.CommandType.prefix;
+    constructor() {
+    }
+    executePrefixCommand({ message, interaction, args, client }) {
+        this.execute({ message, interaction, args, client });
+    }
+    executeSlashCommand({ message, interaction, args, client }) {
+        this.execute({ message, interaction, args, client });
+    }
+    selectMenu({ path, interaction, client, framework }) { }
+}
+exports.Command = Command;

package/dist/types/EventParameters.d.ts

@@ -0,0 +1,8 @@
+import { Client, Interaction, Message } from "discord.js";
+import { ZumitoFramework } from "../ZumitoFramework";
+export interface EventParameters {
+    message?: Message;
+    interaction?: Interaction;
+    client?: Client;
+    framework: ZumitoFramework;
+}

package/dist/types/EventParameters.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/FrameworkEvent.d.ts

@@ -0,0 +1,4 @@
+export declare abstract class FrameworkEvent {
+    once: boolean;
+    abstract execute(...args: any[]): Promise<void>;
+}

package/dist/types/FrameworkEvent.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FrameworkEvent = void 0;
+class FrameworkEvent {
+    once = false;
+}
+exports.FrameworkEvent = FrameworkEvent;

package/dist/types/FrameworkSettings.d.ts

@@ -0,0 +1,11 @@
+export interface FrameworkSettings {
+    logLevel?: number;
+    debug?: boolean;
+    discordClientOptions: {
+        intents?: number;
+        token: string;
+        clientId: string;
+    };
+    defaultPrefix?: string;
+    mongoQueryString: string;
+}

package/dist/types/FrameworkSettings.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/Module.d.ts

@@ -0,0 +1,12 @@
+import { Command } from "./Commands";
+import { FrameworkEvent } from "./FrameworkEvent";
+export declare abstract class Module {
+    protected path: string;
+    protected commands: Map<String, Command>;
+    protected events: Map<String, FrameworkEvent>;
+    constructor(path: any);
+    registerCommands(): void;
+    getCommands(): Map<String, Command>;
+    registerEvents(): void;
+    getEvents(): Map<String, FrameworkEvent>;
+}

package/dist/types/Module.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Module = void 0;
+const fs = require('fs');
+const path = require('path');
+class Module {
+    path;
+    commands = new Map();
+    events = new Map();
+    constructor(path) {
+        this.path = path;
+        this.registerCommands();
+        this.registerEvents();
+    }
+    registerCommands() {
+        fs.readdirSync(path.join(this.path, 'commands')).forEach(file => {
+            if (file.endsWith('.js') || file.endsWith('.ts')) {
+                let command = require(`${this.path}/commands/${file}`);
+                command = Object.values(command)[0];
+                command = new command();
+                this.commands.set(command.constructor.name.toLowerCase(), command);
+            }
+        });
+    }
+    getCommands() {
+        return this.commands;
+    }
+    registerEvents() {
+        fs.readdirSync(path.join(this.path, 'events')).forEach(file => {
+            if (file.endsWith('.js') || file.endsWith('.ts')) {
+                let event = require(`${this.path}/events/${file}`);
+                event = Object.values(event)[0];
+                event = new event();
+                this.events.set(event.constructor.name.toLowerCase(), event);
+            }
+        });
+    }
+    getEvents() {
+        return this.events;
+    }
+}
+exports.Module = Module;

package/dist/types/SelectMenuParameters.d.ts

@@ -0,0 +1,8 @@
+import { Client, Interaction } from "discord.js";
+import { ZumitoFramework } from "../ZumitoFramework";
+export interface SelectMenuParameters {
+    path: string[];
+    interaction: Interaction;
+    client: Client;
+    framework: ZumitoFramework;
+}

package/dist/types/SelectMenuParameters.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "zumito-framework",
+  "version": "1.0.0",
+  "description": "Discord.js bot framework",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "/dist"
+  ],
+  "bin": {
+    "generate": "./templateGenerator.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "tsc",
+    "publish": "npm publish",
+    "docs": "typedoc --out docs src"
+  },
+  "author": "fernandomema",
+  "license": "ISC",
+  "dependencies": {
+    "better-logging": "^5.0.0",
+    "discord.js": "^14.2.0",
+    "express": "^4.18.1",
+    "mongoose": "^6.5.2",
+    "plop": "^3.1.1"
+  },
+  "devDependencies": {
+    "typedoc": "^0.23.10",
+    "typescript": "^4.7.4"
+  }
+}

package/templateGenerator.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import path from "node:path";
+import minimist from "minimist";
+import { Plop, run } from "plop";
+
+const args = process.argv.slice(2);
+const argv = minimist(args);
+
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+Plop.prepare({
+  cwd: argv.cwd,
+  configPath: path.join(__dirname, 'plopfile.js'),
+  preload: argv.preload || [],
+  completion: argv.completion,
+  dest: process.cwd()
+}, env => Plop.execute(env, run));