millas 0.2.27 → 0.2.29

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/container/Application.js

@@ -176,7 +176,9 @@ class Application {
             || 3000;
         const _host = host || 'localhost';
 
+
         await this._adapter.listen(_port, _host);
+        console.log(_host,_port)
 
         if (process.env.APP_ENV === "development" && process.env.MILLAS_START_UP && !process.env.MILLERS_NODE_ENV) {
             this._printStartupLog(_host, _port);

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 };