millas 0.2.28 → 0.2.30

package/src/console/CommandContext.js

@@ -0,0 +1,66 @@
+'use strict';
+
+/**
+ * Command Context
+ * Encapsulates all dependencies and configuration for CLI commands
+ */
+class CommandContext {
+  constructor(options = {}) {
+    this.program = options.program;
+    this.container = options.container || null;
+    this.config = options.config || {};
+    this.logger = options.logger || console;
+    this.cwd = options.cwd || process.cwd();
+  }
+
+  /**
+   * Set the DI container (lazy loaded after app bootstrap)
+   */
+  setContainer(container) {
+    this.container = container;
+    return this;
+  }
+
+  /**
+   * Set configuration
+   */
+  setConfig(config) {
+    this.config = config;
+    return this;
+  }
+
+  /**
+   * Get a service from the container
+   */
+  resolve(serviceName) {
+    if (!this.container) {
+      throw new Error('Container not initialized. Cannot resolve services.');
+    }
+    return this.container.resolve(serviceName);
+  }
+
+  /**
+   * Check if running inside a Millas project
+   */
+  isMillasProject() {
+    const fs = require('fs');
+    const path = require('path');
+    
+    const pkgPath = path.join(this.cwd, 'package.json');
+    if (!fs.existsSync(pkgPath)) {
+      return false;
+    }
+    
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+      // Check for millas marker in package.json
+      return pkg.millas === true || 
+             (pkg.dependencies && 'millas' in pkg.dependencies) ||
+             (pkg.devDependencies && 'millas' in pkg.devDependencies);
+    } catch {
+      return false;
+    }
+  }
+}
+
+module.exports = CommandContext;

package/src/console/CommandRegistry.js

@@ -0,0 +1,88 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+
+/**
+ * Command Registry
+ * Auto-discovers and registers all commands
+ */
+class CommandRegistry {
+  constructor(context) {
+    this.context = context;
+    this.commands = new Map();
+  }
+
+  /**
+   * Discover and load all commands from a directory
+   */
+  async discoverCommands(commandsDir) {
+    if (!require('fs').existsSync(commandsDir)) {
+      return;
+    }
+
+    const fs = require('fs').promises;
+    const files = (await fs.readdir(commandsDir))
+      .filter(file => file.endsWith('.js') && file !== 'index.js');
+
+    for (const file of files) {
+      const commandPath = path.join(commandsDir, file);
+      try {
+        await this.loadCommand(commandPath);
+      } catch (err) {
+        console.log(err)
+        console.error(chalk.yellow(`  ⚠ Failed to load command: ${file}`));
+        if (process.env.APP_DEBUG) {
+          console.error(err);
+        }
+      }
+    }
+  }
+
+  /**
+   * Load a single command file
+   */
+  async loadCommand(commandPath) {
+    const CommandClass = require(commandPath);
+    const BaseCommand = require('./BaseCommand');
+    
+    // Support both class-based and function-based commands
+    if (typeof CommandClass === 'function') {
+      // Check if it's a class extending BaseCommand
+      if (CommandClass.prototype instanceof BaseCommand) {
+        const commandInstance = new CommandClass(this.context);
+        await commandInstance.register(); // Now async
+        this.commands.set(commandPath, commandInstance);
+      }
+      // Legacy function-based command (backward compatibility)
+      // else if (CommandClass.length === 1) { // expects (program) argument
+      //   CommandClass(this.context.program);
+      //   this.commands.set(commandPath, CommandClass);
+      // }
+      // Invalid command export
+      // else {
+      //   throw new Error(`Invalid command export in ${commandPath}. Must extend BaseCommand or export function(program).`);
+      // }
+    }
+  }
+
+  /**
+   * Register commands from app/commands/ (user-defined commands)
+   */
+  async discoverUserCommands() {
+    const userCommandsDir = path.join(this.context.cwd, 'app', 'commands');
+    if (require('fs').existsSync(userCommandsDir)) {
+      await this.discoverCommands(userCommandsDir);
+    }
+  }
+
+  /**
+   * Get all registered commands
+   */
+  getCommands() {
+    return Array.from(this.commands.values());
+  }
+}
+
+module.exports = CommandRegistry;

package/src/console/Style.js

@@ -0,0 +1,123 @@
+'use strict';
+
+const chalk = require('chalk');
+
+/**
+ * Bootstrap-inspired styling system for CLI output
+ * Provides consistent theming across all commands
+ */
+class Style {
+  // Bootstrap-style variants
+  success(text) {
+    return chalk.green(text);
+  }
+
+  danger(text) {
+    return chalk.red(text);
+  }
+
+  warning(text) {
+    return chalk.yellow(text);
+  }
+
+  info(text) {
+    return chalk.cyan(text);
+  }
+
+  primary(text) {
+    return chalk.blue(text);
+  }
+
+  secondary(text) {
+    return chalk.gray(text);
+  }
+
+  muted(text) {
+    return chalk.dim(text);
+  }
+
+  light(text) {
+    return chalk.white(text);
+  }
+
+  dark(text) {
+    return chalk.black(text);
+  }
+
+  // Text styles
+  bold(text) {
+    return chalk.bold(text);
+  }
+
+  italic(text) {
+    return chalk.italic(text);
+  }
+
+  underline(text) {
+    return chalk.underline(text);
+  }
+
+  // HTTP method colors
+  method(verb) {
+    const colors = {
+      GET: chalk.green,
+      POST: chalk.blue,
+      PUT: chalk.yellow,
+      PATCH: chalk.magenta,
+      DELETE: chalk.red,
+    };
+    return colors[verb] || chalk.white;
+  }
+
+  // Status indicators
+  checkmark(text = '') {
+    return chalk.green(`✔ ${text}`);
+  }
+
+  cross(text = '') {
+    return chalk.red(`✖ ${text}`);
+  }
+
+  bullet(text = '') {
+    return chalk.cyan(`• ${text}`);
+  }
+
+  arrow(text = '') {
+    return chalk.cyan(`→ ${text}`);
+  }
+
+  // Borders and separators
+  line(length = 80, char = '─') {
+    return chalk.gray(char.repeat(length));
+  }
+
+  // Badges
+  badge(text, variant = 'primary') {
+    const styles = {
+      success: chalk.bgGreen.black,
+      danger: chalk.bgRed.white,
+      warning: chalk.bgYellow.black,
+      info: chalk.bgCyan.black,
+      primary: chalk.bgBlue.white,
+      secondary: chalk.bgGray.white,
+    };
+    const style = styles[variant] || styles.primary;
+    return style(` ${text} `);
+  }
+
+  // Code/path highlighting
+  code(text) {
+    return chalk.cyan(text);
+  }
+
+  path(text) {
+    return chalk.cyan(text);
+  }
+
+  // Key-value pairs
+  kv(key, value) {
+    return `${chalk.dim(key)}: ${chalk.white(value)}`;
+  }
+}
+
+module.exports = Style;

package/src/console/index.js

@@ -1,6 +1,15 @@
 'use strict';
 
-const Command       = require('./Command');
-const CommandLoader = require('./CommandLoader');
+const Command         = require('./Command');
+const CommandLoader   = require('./CommandLoader');
+const BaseCommand     = require('./BaseCommand');
+const CommandContext  = require('./CommandContext');
+const CommandRegistry = require('./CommandRegistry');
 
-module.exports = { Command, CommandLoader };
+module.exports = { 
+  Command, 
+  CommandLoader, 
+  BaseCommand, 
+  CommandContext, 
+  CommandRegistry 
+};

package/src/container/AppInitializer.js

@@ -72,6 +72,16 @@ class AppInitializer {
      * @returns {Application} the booted kernel
      */
     async bootKernel() {
+        // Load .env if not running via CLI (CLI loads it in src/cli.js)
+        if (!process.env.MILLAS_CLI_MODE) {
+            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 cfg = this._config;
         const basePath = cfg.basePath || process.cwd();
 

package/src/facades/DB.js

@@ -0,0 +1,195 @@
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+
+/**
+ * DB Facade - Django-style database access
+ * 
+ * Auto-configures on first use by loading config/database.js
+ * 
+ * Usage:
+ *   const DB = require('millas/src/facades/DB');
+ *   
+ *   // Query builder
+ *   const users = await DB.table('users').where('active', true).get();
+ *   
+ *   // Raw queries
+ *   const result = await DB.select('SELECT * FROM users WHERE id = ?', [1]);
+ *   
+ *   // Transactions
+ *   await DB.transaction(async (trx) => {
+ *     await trx('users').insert({ name: 'John' });
+ *     await trx('posts').insert({ title: 'Hello' });
+ *   });
+ *   
+ *   // Direct connection
+ *   const db = DB.connection();
+ *   await db('users').select('*');
+ */
+class DBFacade {
+  constructor() {
+    this._manager = null;
+    this._configured = false;
+  }
+
+  /**
+   * Get the DatabaseManager instance (auto-configures if needed)
+   */
+  _getManager() {
+    if (!this._configured) {
+      this._configure();
+    }
+    return this._manager;
+  }
+
+  /**
+   * Auto-configure by loading config/database.js
+   */
+  _configure() {
+    if (this._configured) return;
+
+    // Try to find config/database.js from current working directory
+    const configPath = path.resolve(process.cwd(), 'config/database.js');
+    
+    if (!fs.existsSync(configPath)) {
+      throw new Error(
+        'config/database.js not found. Make sure you are in a Millas project directory.'
+      );
+    }
+
+    const config = require(configPath);
+    this._manager = require('../orm/drivers/DatabaseManager');
+    this._manager.configure(config);
+    this._configured = true;
+  }
+
+  /**
+   * Get a database connection
+   * @param {string} name - Connection name (optional, uses default if not provided)
+   */
+  connection(name) {
+    return this._getManager().connection(name);
+  }
+
+  /**
+   * Get the default connection
+   */
+  get db() {
+    return this._getManager().db;
+  }
+
+  /**
+   * Query builder for a table (Laravel: DB::table('users'))
+   * @param {string} tableName
+   */
+  table(tableName) {
+    return this._getManager().table(tableName);
+  }
+
+  /**
+   * Execute raw SQL SELECT
+   * @param {string} sql
+   * @param {Array} bindings
+   */
+  async select(sql, bindings = []) {
+    return this._getManager().select(sql, bindings);
+  }
+
+  /**
+   * Execute INSERT
+   * @param {string} sql
+   * @param {Array} bindings
+   */
+  async insert(sql, bindings = []) {
+    return this._getManager().insert(sql, bindings);
+  }
+
+  /**
+   * Execute UPDATE
+   * @param {string} sql
+   * @param {Array} bindings
+   */
+  async update(sql, bindings = []) {
+    return this._getManager().update(sql, bindings);
+  }
+
+  /**
+   * Execute DELETE
+   * @param {string} sql
+   * @param {Array} bindings
+   */
+  async delete(sql, bindings = []) {
+    return this._getManager().delete(sql, bindings);
+  }
+
+  /**
+   * Execute raw SQL
+   * @param {string} sql
+   * @param {Array} bindings
+   */
+  async raw(sql, bindings = []) {
+    return this._getManager().raw(sql, bindings);
+  }
+
+  /**
+   * Run queries in a transaction
+   * @param {Function} callback
+   */
+  async transaction(callback) {
+    return this._getManager().transaction(callback);
+  }
+
+  /**
+   * Begin a transaction manually
+   */
+  async beginTransaction() {
+    return this._getManager().beginTransaction();
+  }
+
+  /**
+   * Execute a statement
+   * @param {string} sql
+   * @param {Array} bindings
+   */
+  async statement(sql, bindings = []) {
+    return this._getManager().statement(sql, bindings);
+  }
+
+  /**
+   * Execute unprepared statement
+   * @param {string} sql
+   */
+  async unprepared(sql) {
+    return this._getManager().unprepared(sql);
+  }
+
+  /**
+   * Get schema builder
+   */
+  get schema() {
+    return this._getManager().schema;
+  }
+
+  /**
+   * Close all database connections
+   */
+  async closeAll() {
+    if (this._manager) {
+      await this._manager.closeAll();
+    }
+  }
+
+  /**
+   * Close a specific connection
+   * @param {string} name
+   */
+  async close(name) {
+    if (this._manager) {
+      await this._manager.close(name);
+    }
+  }
+}
+
+// Export singleton instance
+module.exports = new DBFacade();

package/src/index.js

@@ -1,8 +1,9 @@
 'use strict';
 
 const Millas = require('./container/MillasApp');
+const DB = require('./facades/DB');
 
 /**
  * @module millas
  */
-module.exports = { Millas };
+module.exports = { Millas, DB };

package/src/scaffold/maker.js

@@ -325,74 +325,134 @@ async function makeShape(name) {
   return write(filePath, lines.join('\n'));
 }
 async function makeCommand(name) {
-  // If name contains ':' it's a namespaced signature like 'email:SendDigest'.
-  // Split off the namespace prefix and use only the last segment for the
-  // class name / filename, but keep the full input as the signature.
-  const parts      = name.split(':');
-  const basePart   = parts[parts.length - 1];                        // e.g. 'SendDigest'
-  const cleanBase  = basePart.replace(/Command$/i, '');              // strip trailing Command
-  const className  = pascalCase(cleanBase) + 'Command';              // e.g. 'SendDigestCommand'
-
-  // Build signature from the full name:
-  //   'email:SendDigest' → 'email:digest'
-  //   'SendDigest'       → 'send-digest'
-  //   'send-digest'      → 'send-digest'
-  const signatureParts = name
+  // Convert command signature to class name
+  // Examples:
+  //   'user'                  → UserCommand (subcommand group)
+  //   'send:newsletter'       → SendNewsletterCommand (simple)
+  //   'email'                 → EmailCommand (subcommand group)
+  
+  const isGroup = !name.includes(':');
+  
+  const parts = name
     .replace(/Command$/i, '')
     .split(':')
-    .map((seg, i, arr) => {
-      // Last segment: strip camelCase — 'SendDigest' → 'send-digest'
-      if (i === arr.length - 1) {
-        return seg
-          .replace(/([a-z])([A-Z])/g, '$1-$2')
-          .toLowerCase();
-      }
-      // Namespace segments: lowercase as-is
-      return seg.toLowerCase();
-    });
-  const signature = signatureParts.join(':');
+    .map(part => pascalCase(part));
+  
+  const className = parts.join('') + 'Command';
+  const signature = name.toLowerCase();
 
   const filePath = resolveAppPath('app/commands', `${className}.js`);
 
-  const content = `'use strict';
+  let content;
+  
+  if (isGroup) {
+    // Generate subcommand group template
+    content = `'use strict';
 
-const { Command } = require('millas/console');
+const { BaseCommand } = require('millas/console');
 
 /**
  * ${className}
  *
- * Run with:  millas call ${signature}
+ * Command group - methods become subcommands automatically.
+ * Class name auto-derived: ${className} → ${signature}:*
+ *
+ * Examples:
+ *   millas ${signature}:create --name <value>
+ *   millas ${signature}:update <id> --name <value>
+ *   millas ${signature}:delete <id>
  */
-class ${className} extends Command {
-  static signature   = '${signature}';
-  static description = 'Description of ${signature}';
+class ${className} extends BaseCommand {
+  // Optional: Add descriptions for subcommands
+  // static commands = {
+  //   create: 'Create a new ${signature}',
+  //   update: 'Update a ${signature}',
+  //   delete: 'Delete a ${signature}',
+  // };
+
+  // Private helper (underscore = not a command)
+  // async _get${pascalCase(signature)}(id) {
+  //   return this.container.resolve('Database')
+  //     .table('${signature}s').find(id);
+  // }
+
+  // Subcommand: Only options
+  async create({ name }) {
+    // millas ${signature}:create --name <value>
+    this.info('Creating ${signature}...');
+    this.success('${pascalCase(signature)} created!');
+  }
 
-  // Optional: positional arguments
-  // static args = [
-  //   { name: 'target', description: 'The target to act on', default: 'all' },
-  // ];
+  // Subcommand: Positional + options
+  async update(id, { name }) {
+    // millas ${signature}:update <id> --name <value>
+    this.info(\`Updating ${signature} \${id}...\`);
+    this.success('${pascalCase(signature)} updated!');
+  }
 
-  // Optional: named options / flags
+  // Subcommand: Only positional
+  async delete(id) {
+    // millas ${signature}:delete <id>
+    this.info(\`Deleting ${signature} \${id}...\`);
+    this.success('${pascalCase(signature)} deleted!');
+  }
+}
+
+module.exports = ${className};
+`;
+  } else {
+    // Generate simple command template
+    content = `'use strict';
+
+const { BaseCommand } = require('millas/console');
+
+/**
+ * ${className}
+ *
+ * Simple command - uses handle() method.
+ * Command name auto-derived: ${className} → ${signature}
+ * Run with: millas ${signature}
+ */
+class ${className} extends BaseCommand {
+  static description = 'Description of ${signature}';
+  
+  // Optional: simple options (declarative)
   // static options = [
-  //   { flag: '--dry-run',    description: 'Preview without making changes' },
-  //   { flag: '--limit <n>',  description: 'Max items to process', default: '50' },
+  //   { flags: '--dry-run', description: 'Preview without making changes' },
+  //   { flags: '--limit <n>', description: 'Max items', defaultValue: '50' },
   // ];
 
-  async handle() {
-    // const target = this.argument('target');
-    // const limit  = this.option('limit');
-    // const dry    = this.option('dryRun');
+  // Optional: custom arguments (advanced)
+  // addArguments(parser) {
+  //   parser
+  //     .argument('<file>', 'Input file path')
+  //     .argument('[output]', 'Output file path', 'output.txt')
+  //     .option('--force', 'Force overwrite');
+  // }
+
+  // Optional: validate inputs before execution
+  // async validate(...args) {
+  //   if (!args[0]) {
+  //     throw new Error('Missing required argument');
+  //   }
+  // }
+
+  async handle(options) {
+    // Access options: options.dryRun, options.limit, etc.
+    // Access DI container: this.container.resolve('ServiceName')
+    // Logging helpers: this.info(), this.success(), this.warn(), this.error()
 
     this.info('Running ${signature}...');
 
     // Your command logic here
 
-    this.success('Done.');
+    this.success('Done!');
   }
 }
 
 module.exports = ${className};
 `;
+  }
 
   return write(filePath, content);
 }