meocord 1.2.1 → 1.2.2

package/dist/esm/bin/helper/service-generator.helper.js

@@ -0,0 +1,33 @@
+import path from 'path';
+import { Logger } from '../../common/logger.js';
+import '../../common/theme.js';
+import { validateAndFormatName, buildTemplate, createDirectoryIfNotExists, generateFile } from '../../util/generator-cli.util.js';
+
+class ServiceGeneratorHelper {
+    /**
+   * Generates a service file based on the provided service name.
+   * Validates and formats the service name, creates the necessary directories,
+   * and generates the service file using a predefined template.
+   *
+   * @param serviceName - The name of the service to generate.
+   *                      It can include slashes for nested paths.
+   * @throws Exits the process if the service name is not provided or invalid.
+   */ generateService(serviceName) {
+        if (!serviceName) {
+            this.logger.error('Service name is required.');
+            process.exit(1);
+        }
+        const { parts, kebabCaseName, className } = validateAndFormatName(serviceName);
+        const serviceDir = path.join(process.cwd(), 'src', 'services', ...parts);
+        const serviceFile = path.join(serviceDir, `${kebabCaseName}.service.ts`);
+        const serviceTemplate = buildTemplate(className, 'service.template');
+        createDirectoryIfNotExists(serviceDir);
+        generateFile(serviceFile, serviceTemplate);
+    }
+    constructor(appName){
+        this.appName = appName;
+        this.logger = new Logger(this.appName);
+    }
+}
+
+export { ServiceGeneratorHelper };

package/dist/esm/bin/meocord.js

@@ -0,0 +1,333 @@
+#!/usr/bin/env node
+import path from 'path';
+import webpack from 'webpack';
+import { Logger } from '../common/logger.js';
+import '../common/theme.js';
+import { spawn } from 'node:child_process';
+import { capitalize } from 'lodash-es';
+import wait from '../util/wait.util.js';
+import { GeneratorCLI } from './generator.js';
+import * as fs from 'node:fs';
+import { setEnvironment, compileAndValidateConfig } from '../util/common.util.js';
+import { Command } from 'commander';
+import { simpleGit } from 'simple-git';
+import chalk from 'chalk';
+import { execSync } from 'child_process';
+import { ensureReady, configureCommandHelp } from '../util/meocord-cli.util.js';
+import packageJson from '../package.json.js';
+import { fileURLToPath } from 'url';
+
+const __filename$1 = fileURLToPath(import.meta.url);
+const __dirname$1 = path.dirname(__filename$1);
+/**
+ * A Command Line Interface (CLI) for managing the MeoCord application.
+ */ class MeoCordCLI {
+    /**
+   * Configures and runs the MeoCord CLI.
+   */ async run() {
+        let program = new Command();
+        program.name(this.appName.toLowerCase()).description(`CLI for managing the ${this.appName} application`).version(this.version);
+        program.command('show').description('Display information').option('-w, --warranty', 'Display warranty disclaimer').option('-c, --license', 'Display licensing conditions and usage rights').action((options)=>{
+            if (!options.warranty && !options.license) {
+                program.commands.find((cmd)=>cmd.name() === 'show')?.outputHelp();
+                process.exit(1);
+            }
+            if (options.warranty) {
+                console.log(`
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+The authors of this software are not responsible for damages caused
+by the usage, misuse, or inability to use the software.
+
+See the GNU General Public License for full details:
+<https://www.gnu.org/licenses/>.
+      `);
+            }
+            if (options.license) {
+                console.log(`
+This program is free software: you can redistribute it and/or
+modify it under the terms of the GNU General Public License as
+published by the Free Software Foundation, either version 3 of
+the License, or (at your option) any later version.
+
+Key conditions of the GNU GPL v3:
+- You can use this software for personal, academic, or commercial purposes.
+- If you distribute modified versions, you must share the source code under the same GPL v3 license.
+- The original copyright must be retained.
+
+For full license details, refer to:
+<https://www.gnu.org/licenses/gpl-3.0.txt>
+      `);
+            }
+        });
+        program.command('create <app-name>').description('Create a new MeoCord application').action(async (appName)=>await this.createApp(appName));
+        program.command('build').description('Build the application').option('-d, --dev', 'Build in development mode').option('-p, --prod', 'Build in production mode').action(async (options)=>{
+            await ensureReady();
+            const mode = options.prod ? 'production' : 'development';
+            setEnvironment(mode);
+            await compileAndValidateConfig();
+            await this.build(mode);
+        });
+        program.command('start').description('Start the application').option('-b, --build', 'Pre-build before starting').option('-d, --dev', 'Start in development mode').option('-p, --prod', 'Start in production mode').action(async (options)=>{
+            await ensureReady();
+            const mode = options.prod ? 'production' : 'development';
+            setEnvironment(mode);
+            if (options.build || options.dev) {
+                await compileAndValidateConfig();
+            }
+            if (options.build) {
+                await this.build(mode);
+            }
+            options.prod ? await this.startProd() : await this.startDev();
+        });
+        program = this.generatorCLI.register(program);
+        configureCommandHelp(program);
+        program.showHelpAfterError().parse(process.argv);
+    }
+    async createApp(appName) {
+        const kebabCaseAppName = appName.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+        const appPath = path.resolve(process.cwd(), kebabCaseAppName);
+        const gitRepo = 'https://github.com/l7aromeo/meocord-template.git';
+        console.info(chalk.blueBright(`🚀 Creating a new MeoCord app: ${chalk.bold(kebabCaseAppName)}`));
+        try {
+            // Validate if directory already exists
+            if (fs.existsSync(appPath)) {
+                console.error(chalk.red(`❌ Directory "${chalk.bold(kebabCaseAppName)}" already exists.`));
+                await wait(100);
+                process.exit(1);
+            }
+            // Check Node.js version
+            const MINIMUM_NODE_VERSION = '22.14.0';
+            const [major, minor, patch] = process.version.slice(1).split('.').map(Number);
+            const [minMajor, minMinor, minPatch] = MINIMUM_NODE_VERSION.split('.').map(Number);
+            if (major < minMajor || major === minMajor && minor < minMinor || major === minMajor && minor === minMinor && patch < minPatch) {
+                console.error(chalk.red(`❌ Node.js v${MINIMUM_NODE_VERSION} or higher is required. Current version: v${process.version}.`));
+                await wait(100);
+                process.exit(1);
+            }
+            // Clone the template repository
+            console.info(chalk.blueBright('📦 Fetching template...'));
+            await simpleGit().clone(gitRepo, appPath);
+            console.log(chalk.green(`✔ App successfully created at: ${chalk.bold(appPath)}`));
+            // Remove .git history from template
+            fs.rmSync(path.join(appPath, '.git'), {
+                recursive: true,
+                force: true
+            });
+            // Initialize a new Git repository
+            console.info(chalk.blueBright('🔧 Initializing Git repository...'));
+            const git = simpleGit(appPath);
+            await git.init();
+            await git.add('./*');
+            await git.commit('Initial commit');
+            console.log(chalk.green('✔ Git repository initialized.'));
+            // Install dependencies
+            console.info(chalk.blueBright('📦 Installing dependencies...'));
+            execSync(`cd ${kebabCaseAppName} && corepack enable && yarn install`, {
+                stdio: 'inherit'
+            });
+            console.log(chalk.green('✔ Dependencies installed successfully.'));
+            console.log(chalk.greenBright(`🎉 MeoCord app "${chalk.bold(kebabCaseAppName)}" is ready!`));
+        } catch (error) {
+            console.error(chalk.red(`❌ Failed to create app: ${error instanceof Error ? error.message : String(error)}`));
+            await wait(100);
+            process.exit(1);
+        }
+    }
+    /**
+   * Builds the MeoCord application in the specified mode.
+   *
+   * @param mode - The build mode ('production' or 'development').
+   */ async build(mode) {
+        try {
+            this.clearConsole();
+            this.logger.info(`Building ${mode} version...`);
+            const webpackConfig = (await import(this.webpackConfigPath)).default;
+            const compiler = webpack({
+                ...webpackConfig,
+                mode
+            });
+            if (!compiler) {
+                this.logger.error('Failed to create webpack compiler instance.');
+                throw new Error('Failed to create webpack compiler instance.');
+            }
+            // Workaround for Bun: Keep the event loop alive while webpack runs
+            // Bun sometimes exits before async callbacks fire
+            let keepAliveTimer = null;
+            await new Promise((resolve, reject)=>{
+                keepAliveTimer = setInterval(()=>{
+                // Keeps event loop active
+                }, 100);
+                compiler.run((err, stats)=>{
+                    if (keepAliveTimer) {
+                        clearInterval(keepAliveTimer);
+                        keepAliveTimer = null;
+                    }
+                    if (err) {
+                        this.logger.error(`Build encountered an error: ${err.message}`);
+                        return reject(`Build encountered an error: ${err.message}`);
+                    }
+                    if (stats?.hasErrors()) {
+                        this.logger.error('Build failed due to errors in the compilation process:', stats.compilation.errors);
+                    } else {
+                        this.logger.info(`${capitalize(mode)} build completed successfully.`);
+                    }
+                    compiler.close((closeErr)=>{
+                        if (closeErr) {
+                            this.logger.error(`Error occurred while closing the compiler: ${closeErr.message}`);
+                            return reject(`Error occurred while closing the compiler: ${closeErr.message}`);
+                        }
+                        resolve();
+                    });
+                });
+            });
+        } catch (error) {
+            this.logger.error(`Build process failed: ${error.message}`);
+            await wait(100);
+            process.exit(1);
+        }
+    }
+    /**
+   * Starts the MeoCord application in development mode with live updates.
+   */ async startDev() {
+        try {
+            this.clearConsole();
+            this.logger.log('Starting watch mode...');
+            const webpackConfig = (await import(this.webpackConfigPath)).default;
+            const compiler = webpack({
+                ...webpackConfig,
+                mode: 'development'
+            });
+            if (!compiler) {
+                this.logger.error('Failed to create webpack compiler instance.');
+                await wait(100);
+                process.exit(1);
+            }
+            let nodemonProcess = null;
+            let isRunning = false;
+            const watch = ()=>compiler.watch({}, (err, stats)=>{
+                    if (err) {
+                        this.logger.error(`Webpack Error: ${err.message}`);
+                        return;
+                    }
+                    if (stats?.hasErrors()) {
+                        this.logger.error('Build failed due to errors in the compilation process:', stats.compilation.errors);
+                    } else {
+                        if (nodemonProcess) {
+                            nodemonProcess.kill();
+                            nodemonProcess = null;
+                        }
+                        nodemonProcess = spawn('npx -y nodemon', [
+                            '-q',
+                            this.mainJSPath
+                        ], {
+                            shell: true,
+                            cwd: this.projectRoot,
+                            stdio: 'inherit'
+                        });
+                        isRunning = true;
+                    }
+                });
+            watch();
+            let debounceWatcher;
+            const fsWatcher = fs.watch(path.resolve(process.cwd(), 'meocord.config.ts'), ()=>{
+                clearTimeout(debounceWatcher);
+                debounceWatcher = setTimeout(async ()=>{
+                    if (isRunning && nodemonProcess) {
+                        isRunning = false;
+                        this.logger.log('MeoCord config change detected, reloading config...');
+                        if (nodemonProcess && !nodemonProcess.killed) {
+                            nodemonProcess.kill();
+                            nodemonProcess = null;
+                        }
+                        await new Promise((resolve)=>compiler.close(resolve));
+                        watch();
+                    }
+                }, 300);
+            });
+            let sigintReceived = false;
+            process.on('SIGINT', async ()=>{
+                if (sigintReceived) {
+                    // Second Ctrl+C — force kill and exit immediately
+                    if (nodemonProcess && !nodemonProcess.killed) nodemonProcess.kill('SIGKILL');
+                    process.exit(1);
+                }
+                sigintReceived = true;
+                // Nodemon and the bot already received SIGINT from the process group.
+                // Clean up parent-owned resources and wait for nodemon to exit.
+                fsWatcher.close();
+                if (nodemonProcess && !nodemonProcess.killed) {
+                    nodemonProcess.on('exit', async ()=>{
+                        await new Promise((resolve)=>compiler.close(resolve));
+                        process.exit(0);
+                    });
+                } else {
+                    await new Promise((resolve)=>compiler.close(resolve));
+                    process.exit(0);
+                }
+            });
+        } catch (error) {
+            this.logger.error(`Failed to start: ${error.message}`);
+        }
+    }
+    /**
+   * Starts the MeoCord application in production mode.
+   */ async startProd() {
+        try {
+            // Check if mainJS exists before proceeding
+            if (!fs.existsSync(this.mainJSPath)) {
+                this.logger.error(`Main entry file (main.js) not found! You might need to build before running in production mode.`);
+                await wait(100);
+                process.exit(1);
+            }
+            this.clearConsole();
+            this.logger.log('Starting...');
+            const start = spawn(`node ${this.mainJSPath}`, {
+                shell: true,
+                cwd: this.projectRoot,
+                stdio: 'inherit'
+            }).on('spawn', this.clearConsole);
+            start.on('exit', (code)=>{
+                process.exit(code ?? 0);
+            });
+            let sigintReceived = false;
+            process.on('SIGINT', ()=>{
+                if (sigintReceived) {
+                    // Second Ctrl+C — force kill child and exit immediately
+                    if (!start.killed) start.kill('SIGKILL');
+                    process.exit(1);
+                }
+                sigintReceived = true;
+            // Child process receives SIGINT from the process group directly.
+            // Wait for it to exit via the 'exit' handler above.
+            });
+        } catch (error) {
+            this.logger.error('Failed to start:', error instanceof Error ? error.message : String(error));
+            await wait(100);
+            process.exit(1);
+        }
+    }
+    /**
+   * Clears the console on all platforms.
+   */ clearConsole() {
+        process.stdout.write('\u001b[3J\u001b[2J\u001b[H');
+    }
+    constructor(){
+        this.appName = 'MeoCord';
+        this.logger = new Logger(this.appName);
+        this.projectRoot = process.cwd();
+        this.mainJSPath = path.join(this.projectRoot, 'dist', 'main.js');
+        this.webpackConfigPath = path.resolve(__dirname$1, '..', '..', '..', 'webpack.config.js');
+        this.generatorCLI = new GeneratorCLI(this.appName);
+        this.version = packageJson.version;
+    }
+}
+// Create an instance of the CLI and run it
+const cli = new MeoCordCLI();
+cli.run().catch(async (error)=>{
+    cli.logger.error('Failed to initialize CLI:', error?.message || error);
+    await wait(100);
+    process.exit(1);
+});

package/dist/esm/common/index.js

@@ -0,0 +1,2 @@
+export { Logger } from './logger.js';
+export { Theme } from './theme.js';

package/dist/esm/common/logger.js

@@ -0,0 +1,72 @@
+import { inspect } from 'node:util';
+import dayjs from 'dayjs';
+import utc from 'dayjs/plugin/utc.js';
+import timezone from 'dayjs/plugin/timezone.js';
+import { loadMeoCordConfig } from '../util/meocord-config-loader.util.js';
+import chalk from 'chalk';
+
+dayjs.extend(utc);
+dayjs.extend(timezone);
+class Logger {
+    log(...args) {
+        this.logWithContext('log', args);
+    }
+    info(...args) {
+        this.logWithContext('log', args);
+    }
+    warn(...args) {
+        this.logWithContext('warn', args);
+    }
+    error(...args) {
+        this.logWithContext('error', args);
+    }
+    debug(...args) {
+        this.logWithContext('debug', args);
+    }
+    verbose(...args) {
+        this.logWithContext('log', args);
+    }
+    formatMessage(message, logType) {
+        if (typeof message === 'object' && message !== null) {
+            return inspect(message, {
+                showHidden: true,
+                depth: null,
+                colors: true,
+                compact: false,
+                showProxy: true
+            });
+        }
+        return (this.colorMap[logType] || ((msg)=>msg))(message);
+    }
+    logWithContext(logLevel, messages) {
+        if (messages.length === 0) return;
+        const config = loadMeoCordConfig();
+        const logType = logLevel.toUpperCase();
+        const applyColor = this.colorMap[logType] || ((msg)=>msg);
+        const formattedMessages = messages.map((message)=>this.formatMessage(message, logType));
+        const coloredAppName = config?.appName ? applyColor(chalk.bold(`[${config.appName}]`)) : undefined;
+        const timestamp = chalk.bold(dayjs().format('dddd, MMMM D, YYYY HH:mm:ss [UTC]Z'));
+        const coloredLogLevel = applyColor(chalk.bold(`[${logType}]`));
+        const coloredContext = this.context ? chalk.yellow.bold(`[${this.context}]`) : '';
+        const logTexts = [
+            coloredAppName,
+            timestamp,
+            coloredLogLevel,
+            coloredContext,
+            ...formattedMessages
+        ].filter((log)=>!!log);
+        console[logLevel](...logTexts);
+    }
+    constructor(context){
+        this.context = context;
+        this.colorMap = {
+            LOG: chalk.green,
+            INFO: chalk.cyan,
+            WARN: chalk.yellow,
+            ERROR: chalk.red,
+            DEBUG: chalk.magenta
+        };
+    }
+}
+
+export { Logger };

package/dist/{core/index.d.ts → esm/common/theme.js}

@@ -14,5 +14,11 @@
  *
  * You should have received a copy of the GNU General Public License
  * along with this program. If not, see <https://www.gnu.org/licenses/>.
- */
-export { MeoCordFactory } from '../core/meocord-factory.js';
+ */ class Theme {
+}
+Theme.successColor = '#28A745';
+Theme.infoColor = '#17A2B8';
+Theme.errorColor = '#DC3545';
+Theme.warningColor = '#FFC107';
+
+export { Theme };

package/dist/esm/core/index.js

@@ -0,0 +1 @@
+export { MeoCordFactory } from './meocord-factory.js';

package/dist/esm/core/meocord-factory.js

@@ -0,0 +1,28 @@
+import 'reflect-metadata';
+import { Logger } from '../common/logger.js';
+import '../common/theme.js';
+import { MeoCordApp } from './meocord.app.js';
+import { mainContainer } from '../decorator/container.js';
+import 'inversify';
+import 'discord.js';
+import 'path';
+import 'fs';
+import 'jiti';
+
+class MeoCordFactory {
+    static create(target) {
+        const container = Reflect.getMetadata('inversify:container', target);
+        if (!container) {
+            if (typeof target === 'function') {
+                this.logger.error(`No container found for class: ${target.name}`);
+            } else {
+                this.logger.error('No container found for the provided target.');
+            }
+            throw new Error('No container found on the target class.');
+        }
+        return mainContainer.get(MeoCordApp);
+    }
+}
+MeoCordFactory.logger = new Logger();
+
+export { MeoCordFactory };