millas 0.2.28 → 0.2.30

package/src/commands/new.js

@@ -1,65 +1,70 @@
 'use strict';
 
-const chalk = require('chalk');
+const BaseCommand = require('../console/BaseCommand');
 const fs = require('fs-extra');
 const path = require('path');
 const ora = require('ora');
 const { generateProject } = require('../scaffold/generator');
 
-module.exports = function (program) {
-  program
-    .command('new <project-name>')
-    .description('Create a new Millas project')
-    .option('--no-install', 'Skip npm install')
-    .action(async (projectName, options) => {
-      console.log();
-      console.log(chalk.cyan('  ⚡ Millas Framework'));
-      console.log(chalk.gray('  Creating a new project...\n'));
+class NewCommand extends BaseCommand {
+  static description = 'Create a new Millas project';
 
-      const targetDir = path.resolve(process.cwd(), projectName);
+  async onInit(register) {
+    register
+      .command(async (projectName, install) => {
+        this.logger.log('');
+        this.logger.log(this.style.info('  ⚡ Millas Framework'));
+        this.logger.log(this.style.muted('  Creating a new project...\n'));
 
-      if (fs.existsSync(targetDir)) {
-        console.error(chalk.red(`  ✖ Directory "${projectName}" already exists.\n`));
-        process.exit(1);
-      }
+        const targetDir = path.resolve(this.cwd, projectName);
 
-      const spinner = ora(`  Scaffolding project ${chalk.bold(projectName)}`).start();
-
-      try {
-        await generateProject(projectName, targetDir);
-        spinner.succeed(chalk.green(`  Project "${projectName}" created successfully!`));
-
-        if (options.install !== false) {
-          const installSpinner = ora('  Installing dependencies...').start();
-          const { execSync } = require('child_process');
-          execSync('npm install', { cwd: targetDir, stdio: 'ignore' });
-          installSpinner.succeed(chalk.green('  Dependencies installed!'));
+        if (fs.existsSync(targetDir)) {
+          throw new Error(`Directory "${projectName}" already exists.`);
         }
 
-        // Auto-generate APP_KEY into the new project's .env
+        const spinner = ora(`  Scaffolding project ${this.style.bold(projectName)}`).start();
+
         try {
-          const { Encrypter } = require('../encryption/Encrypter');
-          const envPath = path.join(targetDir, '.env');
-          const key = Encrypter.generateKey('AES-256-CBC');
-          if (fs.existsSync(envPath)) {
-            let envContent = fs.readFileSync(envPath, 'utf8');
-            envContent = /^APP_KEY=/m.test(envContent)
-              ? envContent.replace(/^APP_KEY=.*$/m, `APP_KEY=${key}`)
-              : envContent + `\nAPP_KEY=${key}\n`;
-            fs.writeFileSync(envPath, envContent, 'utf8');
-            console.log(chalk.green('  ✔  Application key generated.'));
+          await generateProject(projectName, targetDir);
+          spinner.succeed(this.style.success(`  Project "${projectName}" created successfully!`));
+
+          if (install !== false) {
+            const installSpinner = ora('  Installing dependencies...').start();
+            const { execSync } = require('child_process');
+            execSync('npm install', { cwd: targetDir, stdio: 'ignore' });
+            installSpinner.succeed(this.style.success('  Dependencies installed!'));
           }
-        } catch { /* non-fatal — developer can run millas key:generate */ }
 
-        console.log();
-        console.log(chalk.bold('  Next steps:'));
-        console.log(chalk.cyan(`    cd ${projectName}`));
-        console.log(chalk.cyan('    millas serve'));
-        console.log();
-      } catch (err) {
-        spinner.fail(chalk.red('  Failed to create project.'));
-        console.error(chalk.red(`\n  Error: ${err.message}\n`));
-        process.exit(1);
-      }
-    });
-};
+          // Auto-generate APP_KEY into the new project's .env
+          try {
+            const { Encrypter } = require('../encryption/Encrypter');
+            const envPath = path.join(targetDir, '.env');
+            const key = Encrypter.generateKey('AES-256-CBC');
+            if (fs.existsSync(envPath)) {
+              let envContent = fs.readFileSync(envPath, 'utf8');
+              envContent = /^APP_KEY=/m.test(envContent)
+                ? envContent.replace(/^APP_KEY=.*$/m, `APP_KEY=${key}`)
+                : envContent + `\nAPP_KEY=${key}\n`;
+              fs.writeFileSync(envPath, envContent, 'utf8');
+              this.logger.log(this.style.success('  ✔  Application key generated.'));
+            }
+          } catch { /* non-fatal — developer can run millas key:generate */ }
+
+          this.logger.log('');
+          this.logger.log(this.style.bold('  Next steps:'));
+          this.logger.log(this.style.info(`    cd ${projectName}`));
+          this.logger.log(this.style.info('    millas serve'));
+          this.logger.log('');
+        } catch (err) {
+          spinner.fail(this.style.danger('  Failed to create project.'));
+          throw err;
+        }
+      })
+      .name('new')
+      .str('projectName', 'Project name')
+      .bool('install', 'Install dependencies')
+      .description('Create a new Millas project');
+  }
+}
+
+module.exports = NewCommand;

package/src/commands/route.js

@@ -1,82 +1,83 @@
 'use strict';
 
-const chalk = require('chalk');
-const path  = require('path');
-const fs    = require('fs-extra');
-
-module.exports = function (program) {
-  program
-    .command('route:list')
-    .description('List all registered routes')
-    .action(async () => {
-      const bootstrapPath = path.resolve(process.cwd(), 'bootstrap/app.js');
-
-      if (!fs.existsSync(bootstrapPath)) {
-        console.error(chalk.red('\n  ✖ Not inside a Millas project.\n'));
-        process.exit(1);
-      }
-
-      process.env.MILLAS_ROUTE_LIST = 'true';
-
-      let route;
-      try {
-        const bootstrap = await require(bootstrapPath);
-        route = bootstrap.route;
-      } catch (err) {
-        console.error(chalk.red(`\n  ✖ Failed to load routes: ${err.message}\n`));
-        process.exit(1);
-      }
-
-      if (!route) {
-        console.log(chalk.yellow('\n  ⚠  Bootstrap did not export { route }.\n'));
-        process.exit(0);
-      }
-
-      const rows = route.list();
-
-      if (rows.length === 0) {
-        console.log(chalk.yellow('\n  No routes registered.\n'));
-        return;
-      }
-
-      console.log();
-      console.log(chalk.bold('  Registered Routes\n'));
-
-      const col = {
-        verb:    8,
-        path:    Math.max(6,  ...rows.map(r => r.path.length)) + 2,
-        handler: Math.max(8,  ...rows.map(r => formatHandler(r).length)) + 2,
-        mw:      Math.max(10, ...rows.map(r => (r.middleware || []).join(', ').length || 1)) + 2,
-      };
-
-      const header =
+const BaseCommand = require('../console/BaseCommand');
+
+class RouteCommand extends BaseCommand {
+  static description = 'Manage application routes';
+
+  async onInit(register) {
+    register
+      .command(this.list)
+      .description('List all registered routes');
+  }
+
+  async list() {
+    if (!this.hasAppBootstrap()) {
+      this.error('Not inside a Millas project.');
+      throw new Error('Not inside a Millas project');
+    }
+
+    process.env.MILLAS_ROUTE_LIST = 'true';
+
+    let route;
+    try {
+      const app = await this.getApp();
+
+      route = app.route;
+    } catch (err) {
+      this.error(`Failed to load routes: ${err.message}`);
+      throw err;
+    }
+
+    if (!route) {
+      this.warn('Bootstrap did not export { route }.');
+      return;
+    }
+
+    const rows = route.list();
+
+    if (rows.length === 0) {
+      this.warn('No routes registered.');
+      return;
+    }
+
+    this.logger.log('');
+    this.logger.log(this.style.bold('  Registered Routes\n'));
+
+    const col = {
+      verb:    8,
+      path:    Math.max(6,  ...rows.map(r => r.path.length)) + 2,
+      handler: Math.max(8,  ...rows.map(r => formatHandler(r).length)) + 2,
+      mw:      Math.max(10, ...rows.map(r => (r.middleware || []).join(', ').length || 1)) + 2,
+    };
+
+    const header =
+      '  ' +
+      this.style.bold(pad('METHOD',     col.verb)) +
+      this.style.bold(pad('PATH',       col.path)) +
+      this.style.bold(pad('HANDLER',    col.handler)) +
+      this.style.bold(pad('MIDDLEWARE', col.mw)) +
+      this.style.bold('NAME');
+
+    this.logger.log(header);
+    this.logger.log(this.style.line(col.verb + col.path + col.handler + col.mw + 10, '─').padStart(col.verb + col.path + col.handler + col.mw + 12));
+
+    for (const r of rows) {
+      const mw   = (r.middleware || []).join(', ') || this.style.secondary('—');
+      const name = r.name || this.style.secondary('—');
+      this.logger.log(
         '  ' +
-        chalk.bold(pad('METHOD',     col.verb)) +
-        chalk.bold(pad('PATH',       col.path)) +
-        chalk.bold(pad('HANDLER',    col.handler)) +
-        chalk.bold(pad('MIDDLEWARE', col.mw)) +
-        chalk.bold('NAME');
-
-      console.log(header);
-      console.log(chalk.gray('  ' + '─'.repeat(col.verb + col.path + col.handler + col.mw + 10)));
-
-      for (const r of rows) {
-        const mw   = (r.middleware || []).join(', ') || chalk.gray('—');
-        const name = r.name || chalk.gray('—');
-        console.log(
-          '  ' +
-          verbChalk(r.verb)(pad(r.verb, col.verb)) +
-          chalk.cyan(pad(r.path, col.path)) +
-          chalk.white(pad(formatHandler(r), col.handler)) +
-          chalk.yellow(pad(mw, col.mw)) +
-          chalk.gray(name)
-        );
-      }
-
-      console.log(chalk.gray(`\n  ${rows.length} route(s) total.\n`));
-      process.exit(0);
-    });
-};
+        this.style.method(r.verb)(pad(r.verb, col.verb)) +
+        this.style.info(pad(r.path, col.path)) +
+        this.style.light(pad(formatHandler(r), col.handler)) +
+        this.style.warning(pad(mw, col.mw)) +
+        this.style.secondary(name)
+      );
+    }
+
+    this.logger.log(this.style.secondary(`\n  ${rows.length} route(s) total.\n`));
+  }
+}
 
 function pad(str, len) { return String(str).padEnd(len); }
 
@@ -87,7 +88,4 @@ function formatHandler(r) {
   return r.method ? `${name}@${r.method}` : name;
 }
 
-function verbChalk(verb) {
-  return { GET: chalk.green, POST: chalk.blue, PUT: chalk.yellow,
-           PATCH: chalk.magenta, DELETE: chalk.red }[verb] || chalk.white;
-}
+module.exports = RouteCommand;

package/src/commands/schedule.js

@@ -1,176 +1,78 @@
 'use strict';
 
-const chalk = require('chalk');
-const path = require('path');
-const fs = require('fs-extra');
-
-module.exports = function (program) {
-
-  program
-    .command('schedule:list')
-    .description('Show all scheduled tasks and their next run times')
-    .action(async () => {
-      const bootstrapPath = path.resolve(process.cwd(), 'bootstrap/app.js');
-      if (!fs.existsSync(bootstrapPath)) {
-        console.error(chalk.red('\n  ✖ Not inside a Millas project.\n'));
-        process.exit(1);
-      }
-
-      // Boot the app to get scheduler
-      let app;
-      try {
-        app = await require(bootstrapPath);
-      } catch (e) {
-        console.error(chalk.red(`\n  ✖ Failed to load app: ${e.message}\n`));
-        process.exit(1);
-      }
-
-      const scheduler = app.make('scheduler');
-      const tasks = scheduler.getTasks();
+const BaseCommand = require('../console/BaseCommand');
+
+class ScheduleCommand extends BaseCommand {
+  static description = 'Manage scheduled tasks';
+
+  async onInit(register) {
+    register
+      .command(async () => {
+        const app = this.getApp();
+        const scheduler = app.make('scheduler');
+        const tasks = scheduler.getTasks();
+
+        if (tasks.length === 0) {
+          this.info('No scheduled tasks found.');
+          this.info('Create routes/schedule.js to define scheduled tasks.');
+          return;
+        }
 
-      console.log();
-      if (tasks.length === 0) {
-        console.log(chalk.gray('  No scheduled tasks found.'));
-        console.log(chalk.gray('  Create routes/schedule.js to define scheduled tasks.'));
-      } else {
-        console.log(chalk.bold('  Scheduled Tasks\n'));
+        this.logger.log(this.style.bold('\n  Scheduled Tasks\n'));
         
         for (const task of tasks) {
-          const status = task.isRunning() ? chalk.yellow('RUNNING') : chalk.green('READY');
+          const status = task.isRunning() 
+            ? this.style.warning('RUNNING') 
+            : this.style.success('READY');
           const nextRun = task.lastRun 
             ? `Last: ${task.lastRun.toLocaleString()}`
-            : chalk.gray('Never run');
+            : this.style.muted('Never run');
           
-          console.log(`  ${chalk.cyan(task.jobClass.name.padEnd(30))} ${status.padEnd(15)} ${nextRun}`);
+          this.logger.log(`  ${this.style.info(task.jobClass.name.padEnd(30))} ${status.padEnd(15)} ${nextRun}`);
           
           if (task.cronExpression) {
-            console.log(`    ${chalk.gray('Cron:')} ${task.cronExpression}`);
+            this.logger.log(`    ${this.style.muted('Cron:')} ${task.cronExpression}`);
           }
           
           if (Object.keys(task.parameters).length > 0) {
-            console.log(`    ${chalk.gray('Params:')} ${JSON.stringify(task.parameters)}`);
+            this.logger.log(`    ${this.style.muted('Params:')} ${JSON.stringify(task.parameters)}`);
           }
           
           if (task.failures.length > 0) {
             const lastFailure = task.failures[task.failures.length - 1];
-            console.log(`    ${chalk.red('Last failure:')} ${lastFailure.error} (${lastFailure.timestamp.toLocaleString()})`);
+            this.logger.log(`    ${this.style.danger('Last failure:')} ${lastFailure.error} (${lastFailure.timestamp.toLocaleString()})`);
           }
           
-          console.log();
+          this.logger.log('');
+        }
+      })
+      .name('list')
+      .description('Show all scheduled tasks and their next run times');
+
+    register
+      .command(async (taskName) => {
+        await this.appBoot();
+        const app = this.getApp();
+        const scheduler = app.make('scheduler');
+        const tasks = scheduler.getTasks();
+        const task = tasks.find(t => t.jobClass.name === taskName);
+
+        if (!task) {
+          this.error(`Task "${taskName}" not found.`);
+          this.info('Available tasks:');
+          tasks.forEach(t => this.logger.log(this.style.muted(`    - ${t.jobClass.name}`)));
+          throw new Error(`Task "${taskName}" not found`);
         }
-      }
-      
-      process.exit(0);
-    });
-
-  program
-    .command('schedule:test <taskName>')
-    .description('Run a specific scheduled task immediately for testing')
-    .action(async (taskName) => {
-      const bootstrapPath = path.resolve(process.cwd(), 'bootstrap/app.js');
-      if (!fs.existsSync(bootstrapPath)) {
-        console.error(chalk.red('\n  ✖ Not inside a Millas project.\n'));
-        process.exit(1);
-      }
-
-      // Boot the app
-      let app;
-      try {
-        app = await require(bootstrapPath);
-      } catch (e) {
-        console.error(chalk.red(`\n  ✖ Failed to load app: ${e.message}\n`));
-        process.exit(1);
-      }
-
-      const scheduler = app.make('scheduler');
-      const tasks = scheduler.getTasks();
-      const task = tasks.find(t => t.jobClass.name === taskName);
-
-      if (!task) {
-        console.error(chalk.red(`\n  ✖ Task "${taskName}" not found.\n`));
-        console.log(chalk.gray('  Available tasks:'));
-        tasks.forEach(t => console.log(chalk.gray(`    - ${t.jobClass.name}`)));
-        console.log();
-        process.exit(1);
-      }
 
-      console.log(chalk.blue(`\n  ▶ Running ${taskName}...\n`));
+        this.logger.log(this.style.primary(`\n  ▶ Running ${taskName}...\n`));
 
-      try {
         await scheduler._executeTask(task, new Date());
-        console.log(chalk.green(`  ✔ ${taskName} completed successfully.\n`));
-      } catch (error) {
-        console.error(chalk.red(`  ✖ ${taskName} failed: ${error.message}\n`));
-        process.exit(1);
-      }
-
-      process.exit(0);
-    });
-
-  program
-    .command('make:task <name>')
-    .description('Generate a new scheduled task class')
-    .action(async (name) => {
-      const taskName = name.endsWith('Task') ? name : `${name}Task`;
-      const taskPath = path.resolve(process.cwd(), 'app', 'tasks', `${taskName}.js`);
-
-      // Ensure directory exists
-      await fs.ensureDir(path.dirname(taskPath));
-
-      // Check if file already exists
-      if (await fs.pathExists(taskPath)) {
-        console.error(chalk.red(`\n  ✖ Task ${taskName} already exists.\n`));
-        process.exit(1);
-      }
-
-      // Generate task class
-      const template = `'use strict';
-
-const { Job } = require('millas/core/queue');
-
-/**
- * ${taskName}
- *
- * Scheduled task that runs automatically based on the schedule defined in routes/schedule.js
- *
- * Usage in routes/schedule.js:
- *   Schedule.job(${taskName}).daily().at('09:00');
- */
-class ${taskName} extends Job {
-  /**
-   * Constructor - DI container will inject dependencies automatically
-   */
-  constructor(/* inject dependencies here */) {
-    super();
-    // Store injected dependencies
-  }
-
-  /**
-   * Execute the scheduled task
-   */
-  async handle() {
-    // Implement your scheduled task logic here
-    console.log('${taskName} is running...');
-  }
-
-  /**
-   * Handle task failure (optional)
-   */
-  async failed(error) {
-    console.error('${taskName} failed:', error.message);
+        this.success(`${taskName} completed successfully.`);
+      })
+      .name('test')
+      .str('taskName', 'Task name to run')
+      .description('Run a specific scheduled task immediately for testing');
   }
 }
 
-module.exports = ${taskName};
-`;
-
-      await fs.writeFile(taskPath, template);
-
-      console.log(chalk.green(`\n  ✔ Task created: ${taskPath}`));
-      console.log(chalk.gray('\n  Next steps:'));
-      console.log(chalk.gray(`    1. Implement the handle() method in ${taskName}`));
-      console.log(chalk.gray(`    2. Add the task to routes/schedule.js:`));
-      console.log(chalk.gray(`       Schedule.job(${taskName}).daily().at('09:00');`));
-      console.log();
-    });
-};
+module.exports = ScheduleCommand;