millas 0.2.27 → 0.2.29

package/bin/millas.js

@@ -2,5 +2,15 @@
 
 'use strict';
 
-const { program } = require('../src/cli');
-program.parse(process.argv);
+const { program, bootstrap } = require('../src/cli');
+
+// Bootstrap async then parse
+(async () => {
+  try {
+    await bootstrap();
+    await program.parseAsync(process.argv);
+  } catch (err) {
+    console.error(err);
+    process.exitCode = 1;
+  }
+})();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "millas",
-  "version": "0.2.27",
+  "version": "0.2.29",
   "description": "A modern batteries-included backend framework for Node.js — built on Express, inspired by Laravel, Django, and FastAPI",
   "main": "src/index.js",
   "exports": {
@@ -56,6 +56,7 @@
   },
   "peerDependencies": {
     "express": "^4.18.0",
+    "pg": "^8.20.0",
     "multer": "^1.4.5 || ^2.0.0",
     "@aws-sdk/client-s3": "^3.0.0",
     "@aws-sdk/s3-request-presigner": "^3.0.0"

package/src/cli.js

@@ -2,34 +2,131 @@
 // Set CLI mode globally for all commands
 process.env.MILLAS_CLI_MODE = 'true';
 
+// Load .env file early (before any commands are loaded)
+const path = require('path');
+const fs = require('fs');
+const envPath = path.resolve(process.cwd(), '.env');
+if (fs.existsSync(envPath)) {
+  require('dotenv').config({ path: envPath, override: false });
+}
+
 const { Command } = require('commander');
 const chalk = require('chalk');
+const CommandContext = require('./console/CommandContext');
+const CommandRegistry = require('./console/CommandRegistry');
+
+// Initialize Commander program
 const program = new Command();
 
 program
   .enablePositionalOptions()
   .name('millas')
   .description(chalk.cyan('⚡ Millas — A modern batteries-included Node.js framework'))
-  .version('0.2.12-beta-1');
-
-// Load all command modules
-require('./commands/new')(program);
-require('./commands/serve')(program);
-require('./commands/make')(program);
-require('./commands/migrate')(program);
-require('./commands/route')(program);
-require('./commands/queue')(program);
-require('./commands/schedule')(program);
-require('./commands/createsuperuser')(program);
-require('./commands/lang')(program);
-require('./commands/key')(program);
-require('./commands/call')(program);
-
-// Unknown command handler
+  .version(require('../package.json').version)
+  .option('--debug', 'Enable debug mode with verbose output');
+
+// Configure help
+program.configureHelp({
+  sortSubcommands: true,
+  sortOptions: true,
+});
+
+// Handle --debug flag globally
+program.hook('preAction', (thisCommand) => {
+  if (thisCommand.opts().debug) {
+    process.env.DEBUG = 'true';
+  }
+});
+
+// Create command context
+const context = new CommandContext({
+  program,
+  cwd: process.cwd(),
+  logger: console,
+});
+
+// Initialize command registry
+const registry = new CommandRegistry(context);
+
+// Bootstrap function (async)
+async function bootstrap() {
+  // Auto-discover and register built-in commands
+  const commandsDir = path.join(__dirname, 'commands');
+  await registry.discoverCommands(commandsDir);
+
+  // Auto-discover user-defined commands (if inside a Millas project)
+  if (context.isMillasProject()) {
+    await registry.discoverUserCommands();
+  }
+}
+
+// Unknown command handler with smart suggestions
 program.on('command:*', ([cmd]) => {
-  console.error(chalk.red(`\n  Unknown command: ${chalk.bold(cmd)}\n`));
-  console.log(`  Run ${chalk.cyan('millas --help')} to see available commands.\n`);
-  process.exit(1);
+  const Style = require('./console/Style');
+  const style = new Style();
+  
+  // Check if this looks like a namespace (e.g., 'lang', 'user', 'migrate')
+  const allCommands = program.commands.map(c => c.name());
+  const namespaceCommands = allCommands.filter(c => c.startsWith(cmd + ':'));
+  
+  if (namespaceCommands.length > 0) {
+    // User typed a namespace without subcommand
+    console.error(style.danger(`\n  ✖ Command '${cmd}' requires a subcommand.\n`));
+    console.log(style.info(`  Available ${cmd} commands:\n`));
+    
+    namespaceCommands.forEach(fullCmd => {
+      const subCmd = fullCmd.substring(cmd.length + 1);
+      const cmdObj = program.commands.find(c => c.name() === fullCmd);
+      const desc = cmdObj ? cmdObj.description() : '';
+      console.log(`    ${style.primary(fullCmd.padEnd(25))} ${style.secondary(desc)}`);
+    });
+    console.log('');
+  } else {
+    // Truly unknown command - suggest similar ones
+    const similar = allCommands.filter(c => {
+      const base = c.split(':')[0];
+      return base.includes(cmd) || cmd.includes(base) || levenshtein(cmd, base) <= 2;
+    });
+    
+    console.error(style.danger(`\n  ✖ Unknown command: ${style.bold(cmd)}\n`));
+    
+    if (similar.length > 0) {
+      console.log(style.info('  Did you mean one of these?\n'));
+      similar.slice(0, 5).forEach(s => {
+        console.log(`    ${style.primary(s)}`);
+      });
+      console.log('');
+    }
+    
+    console.log(`  Run ${style.primary('millas --help')} to see all available commands.\n`);
+  }
+  
+  process.exitCode = 1;
 });
 
-module.exports = { program };
+// Simple Levenshtein distance for command suggestions
+function levenshtein(a, b) {
+  const matrix = [];
+  for (let i = 0; i <= b.length; i++) {
+    matrix[i] = [i];
+  }
+  for (let j = 0; j <= a.length; j++) {
+    matrix[0][j] = j;
+  }
+  for (let i = 1; i <= b.length; i++) {
+    for (let j = 1; j <= a.length; j++) {
+      if (b.charAt(i - 1) === a.charAt(j - 1)) {
+        matrix[i][j] = matrix[i - 1][j - 1];
+      } else {
+        matrix[i][j] = Math.min(
+          matrix[i - 1][j - 1] + 1,
+          matrix[i][j - 1] + 1,
+          matrix[i - 1][j] + 1
+        );
+      }
+    }
+  }
+  return matrix[b.length][a.length];
+}
+
+module.exports = { program, context, registry, bootstrap };

package/src/commands/call.js

@@ -29,7 +29,7 @@ module.exports = function (program) {
     const bootstrapPath = path.join(process.cwd(), 'bootstrap/app.js');
     if (!fs.existsSync(bootstrapPath)) return;
     
-    require('dotenv').config({ path: path.resolve(process.cwd(), '.env') });
+    // require('dotenv').config({ path: path.resolve(process.cwd(), '.env') });
     
     const basePath = process.cwd();
     const AppServiceProvider = require(path.join(basePath, 'providers/AppServiceProvider'));

package/src/commands/createsuperuser.js

@@ -1,33 +1,23 @@
 'use strict';
 
-const chalk    = require('chalk');
-const path     = require('path');
-const fs       = require('fs-extra');
+const BaseCommand = require('../console/BaseCommand');
+const path = require('path');
+const fs = require('fs-extra');
 const readline = require('readline');
-const Hasher   = require('../auth/Hasher');
+const Hasher = require('../auth/Hasher');
 
-const Log = require("../logger/internal")
+class CreateSuperUserCommand extends BaseCommand {
+  static description = 'Manage superusers and admin accounts';
 
-const TAG = 'Create SuperUser';
+  async onInit(register) {
+    register
+      .command(async (email, name, noinput) => {
+        const { User } = await this.#resolveUserModel();
 
-module.exports = function (program) {
+        this.logger.log(this.style.info('\n  Create Millas Superuser\n'));
 
-  // ── createsuperuser ────────────────────────────────────────────────────────
-  program
-    .command('createsuperuser')
-    .description('Create a superuser in the users table (interactive)')
-    .option('--email <email>', 'Email address (skip prompt)')
-    .option('--name <n>',      'Display name (skip prompt)')
-    .option('--noinput',       'Read password from ADMIN_PASSWORD env var, skip all prompts')
-    .action(async (options) => {
-      try {
-        const { User, Auth } = await resolveUserModel();
-
-        Log.i(TAG,chalk.cyan('Create Millas Superuser'));
-
-        // ── Email ────────────────────────────────────────────────
-        let email = options.email;
-        if (!email) email = await prompt('  Email address: ');
+        // Email
+        if (!email) email = await this.#prompt('  Email address: ');
         email = (email || '').trim().toLowerCase();
         if (!email || !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)) {
           throw new Error('Enter a valid email address.');
@@ -38,229 +28,194 @@ module.exports = function (program) {
           throw new Error(
             `A user with email "${email}" already exists.\n` +
             `  To grant staff access: update the record and set is_staff=true, is_superuser=true.\n` +
-            `  To change their password: millas changepassword --email ${email}`
+            `  To change their password: millas createsuperuser:changepassword --email ${email}`
           );
         }
 
-        // ── Name ─────────────────────────────────────────────────
-        let name = options.name;
-        if (!name && !options.noinput) {
-          name = await prompt('  Display name (optional, press Enter to skip): ');
+        // Name
+        if (!name && !noinput) {
+          name = await this.#prompt('  Display name (optional, press Enter to skip): ');
         }
         name = (name || '').trim() || email.split('@')[0];
 
-        // ── Password ─────────────────────────────────────────────
+        // Password
         let plainPassword;
-        if (options.noinput) {
+        if (noinput) {
           plainPassword = process.env.ADMIN_PASSWORD;
           if (!plainPassword) {
             throw new Error('--noinput requires ADMIN_PASSWORD to be set in the environment.');
           }
         } else {
-          plainPassword = await promptPassword('  Password: ');
-          const confirm = await promptPassword('  Password (again): ');
+          plainPassword = await this.#promptPassword('  Password: ');
+          const confirm = await this.#promptPassword('  Password (again): ');
           if (plainPassword !== confirm) throw new Error('Passwords do not match.');
         }
 
-        validatePassword(plainPassword);
+        this.#validatePassword(plainPassword);
 
-        // ── Create via Auth.register path but with staff flags ───
-        // Hash manually so we can pass the flags in the same create() call.
         const hash = await Hasher.make(plainPassword);
 
         await User.create({
           email,
           name,
-          password:     hash,
-          is_active:    true,
-          is_staff:     true,
+          password: hash,
+          is_active: true,
+          is_staff: true,
           is_superuser: true,
         });
 
-        Log.i(TAG,chalk.green(`✔ Superuser "${email}" created successfully.`));
-        Log.i(TAG,chalk.gray(` Run: millas serve  then visit /admin`));
-      } catch (err) {
-        Log.e(TAG,chalk.red(`✖ ${err.message}`));
-        Log.e(TAG,err.stack);
-        process.exit(1);
-      }
-    });
+        this.success(`Superuser "${email}" created successfully.`);
+        this.info('Run: millas serve  then visit /admin');
+      })
+      .name('createsuperuser')
+      .str('[email]', v => v.email().optional(), 'Email address (skip prompt)')
+      .str('[name]', v => v.optional(), 'Display name (skip prompt)')
+      .bool('noinput', 'Read password from ADMIN_PASSWORD env var, skip all prompts')
+      .description('Create a superuser in the users table (interactive)');
 
-  // ── changepassword ─────────────────────────────────────────────────────────
-  program
-    .command('changepassword')
-    .description("Change a user's password in the users table")
-    .option('--email <email>', 'Email address of the user')
-    .action(async (options) => {
-      try {
-        const { User } = await resolveUserModel();
+    register
+      .command(async (email) => {
+        const { User } = await this.#resolveUserModel();
 
-        let email = options.email;
-        if (!email) email = await prompt('\n  Email address: ');
+        if (!email) email = await this.#prompt('\n  Email address: ');
         email = (email || '').trim().toLowerCase();
 
         const user = await User.findBy('email', email);
         if (!user) throw new Error(`No user found with email "${email}".`);
 
-        Log.i(TAG,chalk.cyan(`Changing password for: ${user.email}`));
+        this.logger.log(this.style.info(`\n  Changing password for: ${user.email}\n`));
 
-        const plain   = await promptPassword('  New password: ');
-        const confirm = await promptPassword('  New password (again): ');
+        const plain = await this.#promptPassword('  New password: ');
+        const confirm = await this.#promptPassword('  New password (again): ');
         if (plain !== confirm) throw new Error('Passwords do not match.');
-        validatePassword(plain);
+        this.#validatePassword(plain);
 
         const hash = await Hasher.make(plain);
 
         await User.where('id', user.id).update({
-          password:   hash,
+          password: hash,
           updated_at: new Date().toISOString(),
         });
 
-        Log.i(TAG, chalk.green(`✔ Password updated for "${email}".`));
-      } catch (err) {
-        Log.e(TAG, chalk.red(`✖ ${err.message}`));
-        process.exit(1);
-      }
-    });
+        this.success(`Password updated for "${email}".`);
+      })
+      .name('changepassword')
+      .str('[email]', v => v.email().optional(), 'Email address of the user')
+      .description("Change a user's password in the users table");
 
-  // ── listadmins ─────────────────────────────────────────────────────────────
-  program
-    .command('listadmins')
-    .description('List all staff/superusers from the users table')
-    .action(async () => {
-      try {
-        const { User } = await resolveUserModel();
+    register
+      .command(async () => {
+        const { User } = await this.#resolveUserModel();
 
-        // Query for all staff users — is_staff=true
         const users = await User.where('is_staff', true).orderBy('id').get();
 
         if (!users.length) {
-          Log.i(TAG, chalk.yellow('No staff users found.\n  Run: millas createsuperuser'));
+          this.warn('No staff users found.');
+          this.info('Run: millas createsuperuser');
           return;
         }
 
-        Log.i(TAG, chalk.cyan('Staff / Superusers'));
+        this.logger.log(this.style.info('\n  Staff / Superusers\n'));
         const colW = Math.max(...users.map(u => u.email.length)) + 2;
-        Log.i(TAG, chalk.gray(`  ${'ID'.padEnd(5)}  ${'Email'.padEnd(colW)}  ${'Name'.padEnd(20)}  Active  Super`));
-        Log.i(TAG, chalk.gray('  ' + '─'.repeat(colW + 42)));
+        this.logger.log(this.style.muted(`  ${'ID'.padEnd(5)}  ${'Email'.padEnd(colW)}  ${'Name'.padEnd(20)}  Active  Super`));
+        this.logger.log(this.style.muted('  ' + '─'.repeat(colW + 42)));
+        
         for (const u of users) {
-          const active = u.is_active    ? chalk.green('Yes   ') : chalk.red('No    ');
-          const sup    = u.is_superuser ? chalk.green('Yes')    : chalk.gray('No');
-          Log.i(TAG, `  ${String(u.id).padEnd(5)}  ${chalk.cyan(u.email.padEnd(colW))}  ${(u.name || '—').padEnd(20)}  ${active}  ${sup}`);
+          const active = u.is_active ? this.style.success('Yes   ') : this.style.danger('No    ');
+          const sup = u.is_superuser ? this.style.success('Yes') : this.style.muted('No');
+          this.logger.log(`  ${String(u.id).padEnd(5)}  ${this.style.info(u.email.padEnd(colW))}  ${(u.name || '—').padEnd(20)}  ${active}  ${sup}`);
         }
-      } catch (err) {
-        Log.e(TAG, chalk.red(`✖ ${err.message}`));
-        process.exit(1);
-      }
-    });
-};
-
-// ─── Helpers ──────────────────────────────────────────────────────────────────
-
-/**
- * Resolve the User model using the same three-step priority as AuthServiceProvider:
- *
- *   1. config/app.js -> auth_user: 'ModelName'
- *      Looked up by name in app/models/index.js exports.
- *
- *   2. app/models/User.js  (conventional default path)
- *
- *   3. Built-in AuthUser   (abstract fallback)
- *
- * Also boots the DB connection and verifies the resolved model's table exists,
- * giving a clear error if migrations haven't been run yet.
- */
-
-async function resolveUserModel() {
-  const cwd        = process.cwd();
-  const configPath = path.join(cwd, 'config/database.js');
-  if (!fs.existsSync(configPath)) {
-    throw new Error('config/database.js not found. Are you inside a Millas project?');
+        this.logger.log('');
+      })
+      .name('listadmins')
+      .description('List all staff/superusers from the users table');
   }
 
-  // Always require DatabaseManager from the project-local node_modules.
-  // This ensures the same singleton is shared with the project's models,
-  // avoiding the "not configured" error when millas is installed globally.
-  const dbConfig = require(configPath);
-  let DatabaseManager;
-  try {
-    DatabaseManager = require(path.join(cwd, 'node_modules/millas/src/orm/drivers/DatabaseManager'));
-  } catch {
-    DatabaseManager = require('../orm/drivers/DatabaseManager');
-  }
-  DatabaseManager.configure(dbConfig);
-  const db = DatabaseManager.connection();
-
-  // -- Step 1: auth_user from config/app.js --
-  let User;
-  let authUserName = null;
-  try {
-    const appConfig = require(path.join(cwd, 'config/app'));
-    authUserName = appConfig.auth_user || null;
-  } catch { /* config/app.js missing or no auth_user key */ }
-
-  if (authUserName) {
+  async #resolveUserModel() {
+    const configPath = path.join(this.cwd, 'config/database.js');
+    if (!fs.existsSync(configPath)) {
+      throw new Error('config/database.js not found. Are you inside a Millas project?');
+    }
+
+    const dbConfig = require(configPath);
+    let DatabaseManager;
     try {
-      const modelsIndex = require(path.join(cwd, 'app/models/index'));
-      const resolved    = modelsIndex[authUserName];
-      if (!resolved) {
+      DatabaseManager = require(path.join(this.cwd, 'node_modules/millas/src/orm/drivers/DatabaseManager'));
+    } catch {
+      DatabaseManager = require('../orm/drivers/DatabaseManager');
+    }
+    DatabaseManager.configure(dbConfig);
+    const db = DatabaseManager.connection();
+
+    let User;
+    let authUserName = null;
+    try {
+      const appConfig = require(path.join(this.cwd, 'config/app'));
+      authUserName = appConfig.auth_user || null;
+    } catch { /* config/app.js missing or no auth_user key */ }
+
+    if (authUserName) {
+      try {
+        const modelsIndex = require(path.join(this.cwd, 'app/models/index'));
+        const resolved = modelsIndex[authUserName];
+        if (!resolved) {
+          throw new Error(
+            `auth_user: '${authUserName}' not found in app/models/index.js.\n` +
+            `  Available exports: ${Object.keys(modelsIndex).join(', ')}`
+          );
+        }
+        User = resolved;
+      } catch (err) {
+        if (err.message.includes('auth_user:')) throw err;
+        throw new Error(`Could not load app/models/index.js: ${err.message}`);
+      }
+    } else {
+      try {
+        User = require(path.join(this.cwd, 'app/models/User'));
+      } catch {
+        User = require('../auth/AuthUser');
+      }
+    }
+
+    const table = User.table;
+    if (table) {
+      const tableExists = await db.schema.hasTable(table);
+      if (!tableExists) {
         throw new Error(
-          `auth_user: '${authUserName}' not found in app/models/index.js.\n` +
-          `  Available exports: ${Object.keys(modelsIndex).join(', ')}`
+          `Table "${table}" does not exist.\n\n` +
+          `  Did you run migrations?\n` +
+          `  Run: millas migrate\n`
         );
       }
-      User = resolved;
-    } catch (err) {
-      if (err.message.includes('auth_user:')) throw err;
-      throw new Error(`Could not load app/models/index.js: ${err.message}`);
-    }
-  } else {
-    // -- Step 2: try app/models/User.js --
-    try {
-      User = require(path.join(cwd, 'app/models/User'));
-    } catch {
-      // -- Step 3: abstract AuthUser fallback --
-      User = require('../auth/AuthUser');
     }
+
+    return { User, db };
   }
 
-  // -- Verify the model's table exists (uses the model's own table name) --
-  const table = User.table;
-  if (table) {
-    const tableExists = await db.schema.hasTable(table);
-    if (!tableExists) {
-      throw new Error(
-        `Table "${table}" does not exist.\n\n` +
-        `  Did you run migrations?\n` +
-        `  Run: millas migrate\n`
-      );
+  #validatePassword(pw) {
+    if (!pw || pw.length < 8) {
+      throw new Error('This password is too short. It must contain at least 8 characters.');
     }
   }
 
-  return { User, db };
-}
-
-function validatePassword(pw) {
-  if (!pw || pw.length < 8) {
-    throw new Error('This password is too short. It must contain at least 8 characters.');
+  #prompt(question) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise(resolve => rl.question(question, ans => { rl.close(); resolve(ans); }));
   }
-}
 
-function prompt(question) {
-  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise(resolve => rl.question(question, ans => { rl.close(); resolve(ans); }));
+  #promptPassword(question) {
+    return new Promise(resolve => {
+      if (!process.stdin.isTTY) return this.#prompt(question).then(resolve);
+
+      process.stdout.write(question);
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: new (require('stream').Writable)({ write(c, e, cb) { cb(); } }),
+        terminal: true,
+      });
+      rl.question('', ans => { rl.close(); process.stdout.write('\n'); resolve(ans); });
+    });
+  }
 }
 
-function promptPassword(question) {
-  return new Promise(resolve => {
-    if (!process.stdin.isTTY) return prompt(question).then(resolve);
-
-    process.stdout.write(question);
-    const rl = readline.createInterface({
-      input:  process.stdin,
-      output: new (require('stream').Writable)({ write(c, e, cb) { cb(); } }),
-      terminal: true,
-    });
-    rl.question('', ans => { rl.close(); process.stdout.write('\n'); resolve(ans); });
-  });
-}
+module.exports = CreateSuperUserCommand;