millas 0.2.28 → 0.2.30

package/src/commands/serve.js

@@ -1,219 +1,186 @@
 'use strict';
 
-const chalk = require('chalk');
 const path = require('path');
 const fs = require('fs-extra');
-const fsnative = require('fs');
-const {fork} = require('child_process');
+const { fork } = require('child_process');
 const chokidar = require('chokidar');
-const patchConsole = require("../logger/patchConsole");
-const Logger = require("../logger/internal");
+const BaseCommand = require('../console/BaseCommand');
+const patchConsole = require('../logger/patchConsole');
+const Logger = require('../logger/internal');
 
 const WATCH_DIRS = ['app', 'routes', 'config', 'bootstrap', 'providers', 'middleware'];
 const WATCH_EXTS = new Set(['.js', '.mjs', '.cjs', '.json', '.njk', '.env']);
 const DEBOUNCE_MS = 250;
 
-
-// ── HotReloader ───────────────────────────────────────────────────────────────
-
 class HotReloader {
-    constructor(bootstrapPath, publicPort, publicHost) {
-        this._bootstrap = bootstrapPath;
-        this._initialised = false
+  constructor(bootstrapPath) {
+    this._bootstrap = bootstrapPath;
+    this._initialised = false;
+    this._child = null;
+    this._starting = false;
+    this._restarts = 0;
+    this._queue = [];
+    this._watchers = [];
+    this._timer = null;
+  }
+
+  start() {
+    this._spawnChild();
+    this._watch();
+    this._handleSignals();
+  }
+
+  _spawnChild() {
+    if (this._starting) return;
+    
+    this._starting = true;
+    const extra = {};
+    
+    if (!this._initialised) {
+      extra['MILLAS_START_UP'] = true;
+      this._initialised = true;
+    }
 
-        this._child = null;
+    this._child = fork(this._bootstrap, [], {
+      env: {
+        ...process.env,
+        ...extra,
+        MILLAS_CHILD: '1',
+      },
+      stdio: 'inherit',
+    });
+
+    this._child.on('message', msg => {
+      if (msg && msg.type === 'ready') {
         this._starting = false;
-        this._restarts = 0;
+      }
+    });
 
-        // Queued { req, res, timer } entries while child is restarting
-        this._queue = [];
-        this._watchers = [];
-        this._timer = null;
-    }
+    this._child.on('exit', (code, signal) => {
+      this._starting = false;
 
-    start() {
-        this._spawnChild();
-        this._watch();
-        this._handleSignals();
+      if (code !== 0 && signal !== 'SIGTERM' && signal !== 'SIGKILL') {
+        console.error(
+          this.style?.danger('✖  App crashed') ||
+          `✖  App crashed (exit ${code ?? signal}) — fix the error, file watcher will reload…`
+        );
+      }
+    });
+
+    this._child.on('error', err => {
+      this._starting = false;
+      console.error(`✖  ${err.message}`);
+    });
+  }
+
+  _killChild(cb) {
+    if (!this._child || this._child.exitCode !== null) return cb();
+    this._child.once('exit', cb);
+    this._child.kill('SIGTERM');
+  }
+
+  _restart(changedFile) {
+    console.warn(`↺  Reloading${changedFile ? '  ' + changedFile : ''}`);
+    this._restarts++;
+    this._killChild(() => this._spawnChild());
+  }
+
+  _watch() {
+    console.log('✔  Watching for changes…');
+    const cwd = process.cwd();
+    const watchPaths = [
+      ...WATCH_DIRS.map(d => path.join(cwd, d)),
+      path.join(cwd, '.env'),
+      path.join(cwd, '.env.local'),
+    ];
+
+    const watcher = chokidar.watch(watchPaths, {
+      persistent: true,
+      ignoreInitial: true,
+      ignored: /(^|[\/\\])\..(?!env)/,
+      awaitWriteFinish: { stabilityThreshold: 80, pollInterval: 20 },
+    });
+
+    watcher.on('all', (event, filePath) => {
+      if (WATCH_EXTS.has(path.extname(filePath))) {
+        this._scheduleRestart(filePath);
+      }
+    });
+
+    this._watchers.push(watcher);
+  }
+
+  _scheduleRestart(changedFile) {
+    clearTimeout(this._timer);
+    this._timer = setTimeout(() => this._restart(changedFile), DEBOUNCE_MS);
+  }
+
+  _stopWatching() {
+    for (const w of this._watchers) {
+      try {
+        w.close();
+      } catch {}
     }
+    this._watchers = [];
+  }
+
+  _handleSignals() {
+    const cleanup = () => {
+      clearTimeout(this._timer);
+      this._stopWatching();
+      if (this._child) this._child.kill('SIGTERM');
+      process.exit(0);
+    };
+    process.once('SIGINT', cleanup);
+    process.once('SIGTERM', cleanup);
+  }
+}
 
-    _spawnChild() {
-        if (this._starting) {
-            return;
-        }
-        this._starting = true;
-        const extra = {}
-        if (!this._initialised) {
-            extra["MILLAS_START_UP"] = true
-            this._initialised = true
-        }
+class ServeCommand extends BaseCommand {
+  static description = 'Start the development server with hot reload';
 
-        this._child = fork(this._bootstrap, [], {
-            env: {
-                ...extra,
-                MILLAS_CHILD: '1',
-                DEBUG: process.env.APP_DEBUG,
-                MILLAS_HOST: process.env.MILLAS_HOST,
-                MILLAS_PORT: process.env.MILLAS_PORT,
-            },
-            stdio: 'inherit',
-        });
-
-        // Application.listen() sends { type:'ready' } via IPC once bound
-        this._child.on('message', msg => {
-            if (msg && msg.type === 'ready') {
-                this._starting = false;
-            }
-        });
-        //
-        this._child.on('exit', (code, signal) => {
-            this._starting = false;
-
-            if (code !== 0 && signal !== 'SIGTERM' && signal !== 'SIGKILL') {
-                console.error(chalk.red('✖  App crashed') +
-                    chalk.dim(` (exit ${code ?? signal})`) +
-                    chalk.dim(' — fix the error, file watcher will reload…')
-                );
-            }
-        });
-        //
-        this._child.on('error', err => {
-            this._starting = false;
-            console.error(chalk.red(`✖  ${err.message}`));
-        });
-    }
+  async onInit(register) {
+    register
+      .command(async (port, host, reload) => {
+        const restoreAfterPatch = patchConsole(Logger, 'SystemOut');
+        const appBootstrap = path.resolve(this.cwd, 'bootstrap/app.js');
 
-    _killChild(cb) {
-        if (!this._child || this._child.exitCode !== null) return cb();
-        this._child.once('exit', cb);
-        this._child.kill('SIGTERM');
-    }
+        if (!fs.existsSync(appBootstrap)) {
+          throw new Error('No Millas project found here. Make sure bootstrap/app.js exists.');
+        }
 
-    _restart(changedFile) {
+        const publicPort = parseInt(port || process.env.APP_PORT || 3000, 10);
+        const publicHost = host || process.env.APP_HOST || 'localhost';
 
-        console.warn(
-            chalk.yellow('↺') + '  ' +
-            chalk.white('Reloading') +
-            (changedFile ? chalk.blueBright('  ' + changedFile) : '')
+        const env = Object.fromEntries(
+          Object.entries({
+            NODE_ENV: process.env.APP_ENV,
+            MILLERS_NODE_ENV: true,
+            MILLAS_HOST: publicHost,
+            MILLAS_PORT: String(publicPort),
+          }).filter(([, v]) => v !== undefined)
         );
 
-        this._restarts++;
-        this._killChild(() => this._spawnChild());
-    }
-
-    // ── Watcher ───────────────────────────────────────────────────────────────
-
-    _watch() {
-        console.log(chalk.green('✔') + '  ' +
-            chalk.dim('Watching for changes…')
-        );
-        const cwd = process.cwd();
-        const watchPaths = [
-            ...WATCH_DIRS.map(d => path.join(cwd, d)),
-            path.join(cwd, '.env'),
-            path.join(cwd, '.env.local'),
-        ];
-
-        const watcher = chokidar.watch(watchPaths, {
-            persistent: true,
-            ignoreInitial: true,
-            ignored: /(^|[\/\\])\..(?!env)/,
-            // Wait for the file write to settle before reloading.
-            // Prevents double-restarts on editors that truncate then rewrite.
-            awaitWriteFinish: {stabilityThreshold: 80, pollInterval: 20},
-        });
-
-        watcher.on('all', (event, filePath) => {
-            if (WATCH_EXTS.has(path.extname(filePath))) {
-                this._scheduleRestart(filePath);
-            }
-        });
-
-        this._watchers.push(watcher);
-    }
+        Object.assign(process.env, env);
 
-    _scheduleRestart(changedFile) {
-        clearTimeout(this._timer);
-        this._timer = setTimeout(() => this._restart(changedFile), DEBOUNCE_MS);
-    }
+        const enableReload = reload !== false;
 
-    _stopWatching() {
-        for (const w of this._watchers) {
-            try {
-                w.close();
-            } catch {
-            }
+        if (enableReload) {
+          new HotReloader(appBootstrap).start();
+        } else {
+          try {
+            await require(appBootstrap);
+          } catch (e) {
+            throw new Error(`Error starting server: ${e.message}`);
+          }
         }
-        this._watchers = [];
-    }
-
-    // ── Signals ───────────────────────────────────────────────────────────────
-
-    _handleSignals() {
-        const cleanup = () => {
-            clearTimeout(this._timer);
-            this._stopWatching();
-            if (this._child) this._child.kill('SIGTERM');
-            process.exit(0);
-        };
-        process.once('SIGINT', cleanup);
-        process.once('SIGTERM', cleanup);
-    }
+      })
+      .name('serve')
+      .num('port', v => v.optional().min(1).max(65535), 'Port to listen on')
+      .str('host', v => v.optional(), 'Host to bind to')
+      .bool('reload', v => v.default(true), 'Enable hot reload')
+      .description('Start the development server with hot reload');
+  }
 }
 
-// ── Command ────────────────────────────────────────────────────────────────────
-
-module.exports = function (program) {
-    program
-        .command('serve')
-        .description('Start the development server with hot reload')
-        .option('-p, --port <port>', 'Port to listen on')
-        .option('-h, --host <host>', 'Host to bind to')
-        .option('--no-reload', 'Disable hot reload (run once, like production)')
-        .action((options) => {
-
-            require('dotenv').config({ path: path.resolve(process.cwd(), '.env') });
-
-            const restoreAfterPatch = patchConsole(Logger,"SystemOut")
-            let appBootstrap = path.resolve(process.cwd(), 'bootstrap/app.js');
-
-            if (!fs.existsSync(appBootstrap)) {
-                process.stderr.write(chalk.red('\n  ✖  No Millas project found here.\n'));
-                process.stderr.write(chalk.dim('     Make sure bootstrap/app.js exists.\n\n'));
-                process.exit(1);
-            }
-
-            const publicPort = parseInt(options.port ||process.env.APP_PORT, 10);
-            const publicHost = options.host;
-
-                  const env = Object.fromEntries(
-                    Object.entries({
-                        NODE_ENV: process.env.APP_ENV,
-                        MILLERS_NODE_ENV: true,
-                        MILLAS_HOST: publicHost,
-                        MILLAS_PORT: String(publicPort),
-                    }).filter(([, v]) => v !== undefined)
-                );
-
-                Object.assign(process.env, env)
-
-            if (options.reload !== false) {
-                new HotReloader(appBootstrap, publicPort, publicHost).start();
-            } else {
-                try {
-                    require(appBootstrap);
-                } catch (e) {
-                    console.log("Error starting server: ", +e)
-                }
-            }
-        });
-
-};
-
-module.exports.requireProject = function (command) {
-    const bootstrapPath = path.resolve(process.cwd(), 'bootstrap/app.js');
-    if (!fsnative.existsSync(bootstrapPath)) {
-        process.stderr.write(chalk.red(`\n  ✖  Not inside a Millas project (${command}).\n\n`));
-        process.exit(1);
-    }
-};
+module.exports = ServeCommand;

package/src/console/AppCommand.js

@@ -0,0 +1,106 @@
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+
+/**
+ * AppCommand - Base class for commands that need app bootstrapping
+ * 
+ * Provides app context loading for commands that need access to:
+ * - Routes
+ * - Models
+ * - Services
+ * - Configuration
+ */
+class AppCommand {
+
+  /**
+   *
+   * @param context
+   */
+  constructor(context) {
+    this.context = context;
+    this.program = context.program;
+    this.container = context.container;
+    this.logger = context.logger;
+    this.cwd = context.cwd;
+    this._app = null;
+    this._appBootstrapped = false;
+  }
+
+  /**
+   * Get the app bootstrap path
+   * Override this to customize the bootstrap location
+   */
+  getAppBootstrapPath() {
+    return path.resolve(this.cwd, 'bootstrap/app.js');
+  }
+
+  /**
+   * Check if app bootstrap exists
+   */
+  hasAppBootstrap() {
+    return fs.existsSync(this.getAppBootstrapPath());
+  }
+
+  /**
+   * Bootstrap the application
+   * Override this method to customize bootstrapping behavior
+   * 
+   * @returns {Object} The bootstrapped app
+   */
+  async #appBoot() {
+    if (this._appBootstrapped) {
+      return this._app;
+    }
+
+    const bootstrapPath = this.getAppBootstrapPath();
+
+    if (!fs.existsSync(bootstrapPath)) {
+      throw new Error('Not inside a Millas project. bootstrap/app.js not found.');
+    }
+
+    try {
+      this._app = await require(bootstrapPath);
+      this._appBootstrapped = true;
+      return this._app;
+    } catch (err) {
+      throw new Error(`Failed to bootstrap app: ${err.message}`);
+    }
+  }
+
+  /**
+   * Get the bootstrapped app (lazy loads if needed)
+   * @returns Application
+   */
+  async getApp() {
+    if (!this._appBootstrapped) {
+      await this.#appBoot();
+    }
+    return this._app;
+  }
+
+  /**
+   * Get a specific export from the bootstrapped app
+   * 
+   * @param {string} key - The export key (e.g., 'route', 'app', 'db')
+   * @returns {*} The exported value
+   */
+  async getAppExport(key) {
+    const app = await this.getApp();
+    return app[key];
+  }
+
+  /**
+   * Require app bootstrap (throws if not found)
+   * Use this in commands that MUST have an app context
+   */
+  async requireApp() {
+    if (!this.hasAppBootstrap()) {
+      throw new Error('This command requires a Millas project. Run inside a project directory.');
+    }
+    return await this.getApp();
+  }
+}
+
+module.exports = AppCommand;