millas 0.2.12-beta → 0.2.12-beta-2

package/src/commands/migrate.js

@@ -9,40 +9,81 @@ module.exports = function (program) {
   // ── makemigrations ──────────────────────────────────────────────────────────
   program
     .command('makemigrations')
-    .description('Scan model files, detect schema changes, generate migration files')
-    .action(async () => {
+    .description('Detect model changes and generate migration files (never touches DB)')
+    .option('--dry-run',  'Show what would be generated without writing files')
+    .option('--noinput',  'Non-interactive mode — fails if dangerous fields need resolution')
+    .action(async (options) => {
       try {
-        const ctx            = getProjectContext();
-        const ModelInspector = require('../orm/migration/ModelInspector');
-        const inspector      = new ModelInspector(
-          ctx.modelsPath,
-          ctx.migrationsPath,
-          ctx.snapshotPath,
-        );
-        const result = await inspector.makeMigrations();
+        const ctx  = getProjectContext();
+        const Mk   = require('../orm/migration/Makemigrations');
+        const mk   = new Mk(ctx.modelsPath, ctx.appMigPath, ctx.systemMigPath, {
+          nonInteractive: options.noinput || false,
+        });
+        const result = await mk.run({ dryRun: options.dryRun });
 
         if (result.files.length === 0) {
-          console.log(chalk.yellow(`\n  ${result.message}\n`));
+          console.log(chalk.yellow(`\n  No changes detected.\n`));
         } else {
-          console.log(chalk.green(`\n  ✔  ${result.message}`));
-          result.files.forEach(f => console.log(chalk.cyan(`     + ${f}`)));
-          console.log(chalk.gray('\n  Run: millas migrate   to apply these migrations.\n'));
+          if (options.dryRun) {
+            console.log(chalk.cyan('\n  Would generate:'));
+          } else {
+            console.log(chalk.green('\n  Migrations generated:'));
+          }
+          result.files.forEach(f => console.log(chalk.cyan(`    + ${f}`)));
+          result.ops.forEach(op => {
+            // Match Django's +/-/~ prefix style exactly
+            let prefix, label;
+            switch (op.type) {
+              case 'CreateModel':
+                prefix = chalk.green('+'); label = `Create model ${op.table}`; break;
+              case 'DeleteModel':
+                prefix = chalk.red('-');   label = `Delete model ${op.table}`; break;
+              case 'AddField':
+                prefix = chalk.green('+'); label = `Add field ${op.column} to ${op.table}`; break;
+              case 'RemoveField':
+                prefix = chalk.red('-');   label = `Remove field ${op.column} from ${op.table}`; break;
+              case 'AlterField':
+                prefix = chalk.yellow('~'); label = `Alter field ${op.column} on ${op.table}`; break;
+              case 'RenameField':
+                prefix = chalk.yellow('~'); label = `Rename field ${op.oldColumn} on ${op.table} to ${op.newColumn}`; break;
+              case 'RenameModel':
+                prefix = chalk.yellow('~'); label = `Rename model ${op.oldTable} to ${op.newTable}`; break;
+              default:
+                prefix = chalk.gray(' ');   label = op.type;
+            }
+            console.log(chalk.gray(`      ${prefix} ${label}`));
+          });
+          if (!options.dryRun) {
+            console.log(chalk.gray('\n  Run: millas migrate   to apply.\n'));
+          } else {
+            console.log();
+          }
         }
       } catch (err) {
         bail('makemigrations', err);
       }
-      // makemigrations doesn't open a DB connection so no closeDb() needed
     });
 
   // ── migrate ─────────────────────────────────────────────────────────────────
   program
     .command('migrate')
-    .description('Run all pending migrations')
-    .action(async () => {
+    .description('Apply pending migrations in dependency order (never generates migrations)')
+    .option('--fake <name>', 'Mark a migration as applied without running it')
+    .action(async (options) => {
       try {
         const runner = await getRunner();
+
+        if (options.fake) {
+          const [source, name] = options.fake.includes(':')
+            ? options.fake.split(':')
+            : ['app', options.fake];
+          const result = await runner.fake(source, name);
+          console.log(chalk.green(`\n  Marked "${result.key}" as applied (fake).\n`));
+          return;
+        }
+
         const result = await runner.migrate();
-        printMigrationResult(result, 'Ran');
+        printResult(result.ran, 'Applying');
       } catch (err) {
         bail('migrate', err);
       } finally {
@@ -50,18 +91,69 @@ module.exports = function (program) {
       }
     });
 
-  // ── migrate:fresh ────────────────────────────────────────────────────────────
+  // ── migrate:plan ─────────────────────────────────────────────────────────────
   program
-    .command('migrate:fresh')
-    .description('Drop ALL tables then re-run every migration from scratch')
+    .command('migrate:plan')
+    .description('Preview which migrations would run without applying them')
+    .action(async () => {
+      try {
+        const runner  = await getRunner();
+        const pending = await runner.plan();
+
+        if (pending.length === 0) {
+          console.log(chalk.yellow('\n  Nothing to migrate.\n'));
+          return;
+        }
+
+        console.log(chalk.cyan('\n  Migration plan:\n'));
+        pending.forEach(p => {
+          const color = p.source === 'system' ? chalk.gray : chalk.cyan;
+          console.log(color(`    ${p.key}`));
+        });
+        console.log();
+      } catch (err) {
+        bail('migrate:plan', err);
+      } finally {
+        await closeDb();
+      }
+    });
+
+  // ── migrate:status ───────────────────────────────────────────────────────────
+  program
+    .command('migrate:status')
+    .description('Show the status of all migrations')
     .action(async () => {
       try {
-        console.log(chalk.yellow('\n  ⚠  Dropping all tables…\n'));
         const runner = await getRunner();
-        const result = await runner.fresh();
-        printMigrationResult(result, 'Ran');
+        const rows   = await runner.status();
+
+        if (rows.length === 0) {
+          console.log(chalk.yellow('\n  No migrations found.\n'));
+          return;
+        }
+
+        const colW = Math.max(...rows.map(r => r.key.length)) + 2;
+        console.log(`\n  ${'Migration'.padEnd(colW)}  ${'Status'.padEnd(10)}  Batch`);
+        console.log(chalk.gray('  ' + '─'.repeat(colW + 20)));
+
+        let lastSource = null;
+        for (const row of rows) {
+          if (row.source !== lastSource) {
+            if (lastSource !== null) console.log();
+            lastSource = row.source;
+          }
+          const status = row.status === 'Applied'
+            ? chalk.green(row.status.padEnd(10))
+            : chalk.yellow(row.status.padEnd(10));
+          const batch = row.batch ? chalk.gray(String(row.batch)) : chalk.gray('—');
+          const label = row.source === 'system'
+            ? chalk.gray(row.key.padEnd(colW))
+            : chalk.cyan(row.key.padEnd(colW));
+          console.log(`  ${label}  ${status}  ${batch}`);
+        }
+        console.log();
       } catch (err) {
-        bail('migrate:fresh', err);
+        bail('migrate:status', err);
       } finally {
         await closeDb();
       }
@@ -76,7 +168,7 @@ module.exports = function (program) {
       try {
         const runner = await getRunner();
         const result = await runner.rollback(Number(options.steps));
-        printMigrationResult(result, 'Rolled back');
+        printResult(result.rolledBack, 'Reverting');
       } catch (err) {
         bail('migrate:rollback', err);
       } finally {
@@ -84,66 +176,50 @@ module.exports = function (program) {
       }
     });
 
-  // ── migrate:reset ────────────────────────────────────────────────────────────
+  // ── migrate:fresh ────────────────────────────────────────────────────────────
   program
-    .command('migrate:reset')
-    .description('Rollback ALL migrations')
+    .command('migrate:fresh')
+    .description('Drop all tables and re-run every migration from scratch')
     .action(async () => {
       try {
+        console.log(chalk.yellow('\n  ⚠  Dropping all tables…\n'));
         const runner = await getRunner();
-        const result = await runner.reset();
-        printMigrationResult(result, 'Rolled back');
+        const result = await runner.fresh();
+        printResult(result.ran, 'Applying');
       } catch (err) {
-        bail('migrate:reset', err);
+        bail('migrate:fresh', err);
       } finally {
         await closeDb();
       }
     });
 
-  // ── migrate:refresh ──────────────────────────────────────────────────────────
+  // ── migrate:reset ────────────────────────────────────────────────────────────
   program
-    .command('migrate:refresh')
-    .description('Rollback all then re-run all migrations')
+    .command('migrate:reset')
+    .description('Rollback ALL migrations')
     .action(async () => {
       try {
         const runner = await getRunner();
-        const result = await runner.refresh();
-        printMigrationResult(result, 'Ran');
+        const result = await runner.reset();
+        printResult(result.rolledBack, 'Reverting');
       } catch (err) {
-        bail('migrate:refresh', err);
+        bail('migrate:reset', err);
       } finally {
         await closeDb();
       }
     });
 
-  // ── migrate:status ───────────────────────────────────────────────────────────
+  // ── migrate:refresh ──────────────────────────────────────────────────────────
   program
-    .command('migrate:status')
-    .description('Show the status of all migration files')
+    .command('migrate:refresh')
+    .description('Rollback all then re-run all migrations')
     .action(async () => {
       try {
         const runner = await getRunner();
-        const rows   = await runner.status();
-
-        if (rows.length === 0) {
-          console.log(chalk.yellow('\n  No migration files found.\n'));
-          return;
-        }
-
-        const colW = Math.max(...rows.map(r => r.name.length)) + 2;
-        console.log(`\n  ${'Migration'.padEnd(colW)}  ${'Status'.padEnd(10)}  Batch`);
-        console.log(chalk.gray('  ' + '─'.repeat(colW + 20)));
-
-        for (const row of rows) {
-          const status = row.status === 'Ran'
-            ? chalk.green(row.status.padEnd(10))
-            : chalk.yellow(row.status.padEnd(10));
-          const batch = row.batch ? chalk.gray(String(row.batch)) : chalk.gray('—');
-          console.log(`  ${chalk.cyan(row.name.padEnd(colW))}  ${status}  ${batch}`);
-        }
-        console.log();
+        const result = await runner.refresh();
+        printResult(result.ran, 'Applying');
       } catch (err) {
-        bail('migrate:status', err);
+        bail('migrate:refresh', err);
       } finally {
         await closeDb();
       }
@@ -193,10 +269,10 @@ module.exports = function (program) {
 function getProjectContext() {
   const cwd = process.cwd();
   return {
-    migrationsPath: path.join(cwd, 'database/migrations'),
-    seedersPath:    path.join(cwd, 'database/seeders'),
-    modelsPath:     path.join(cwd, 'app/models'),
-    snapshotPath:   path.join(cwd, '.millas/schema.json'),
+    appMigPath:    path.join(cwd, 'database/migrations'),
+    systemMigPath: path.join(__dirname, '../migrations/system'),
+    seedersPath:   path.join(cwd, 'database/seeders'),
+    modelsPath:    path.join(cwd, 'app/models'),
   };
 }
 
@@ -215,31 +291,28 @@ async function getRunner() {
   const MigrationRunner = require('../orm/migration/MigrationRunner');
   const ctx = getProjectContext();
   const db  = await getDbConnection();
-  return new MigrationRunner(db, ctx.migrationsPath);
+  return new MigrationRunner(db, ctx.appMigPath, ctx.systemMigPath);
 }
 
-/**
- * Destroy all open knex connection pools so the CLI process exits cleanly.
- * Without this, knex keeps the event loop alive indefinitely after the
- * command finishes, causing the terminal to appear to hang.
- */
 async function closeDb() {
   try {
     const DatabaseManager = require('../orm/drivers/DatabaseManager');
     await DatabaseManager.closeAll();
-  } catch { /* already closed or never opened — safe to ignore */ }
+  } catch {}
 }
 
-function printMigrationResult(result, verb) {
-  const list = result.ran || result.rolledBack || [];
-  if (list.length === 0) {
-    console.log(chalk.yellow(`\n  ${result.message}\n`));
+function printResult(list, verb) {
+  if (!list || list.length === 0) {
+    console.log(chalk.yellow('\n  Nothing to do.\n'));
     return;
   }
-  console.log(chalk.green(`\n  ✔  ${result.message}`));
-  list.forEach(f =>
-    console.log(chalk.cyan(`     ${verb === 'Ran' ? '+' : '-'} ${f}`))
-  );
+  console.log(chalk.green(`\n  Running migrations:`));
+  for (const entry of list) {
+    const label = typeof entry === 'object' ? entry.label || entry.key : entry;
+    const source = typeof entry === 'object' ? entry.source : null;
+    const color = source === 'system' ? chalk.gray : chalk.cyan;
+    console.log(color(`    ${verb} ${label}... OK`));
+  }
   console.log();
 }
 
@@ -247,4 +320,4 @@ function bail(cmd, err) {
   console.error(chalk.red(`\n  ✖  ${cmd} failed: ${err.message}\n`));
   if (process.env.DEBUG) console.error(err.stack);
   closeDb().finally(() => process.exit(1));
-}
+}

package/src/commands/serve.js

@@ -6,8 +6,9 @@ const fs = require('fs-extra');
 const fsnative = require('fs');
 const {fork} = require('child_process');
 const chokidar = require('chokidar');
-
-// ── ASCII banner ──────────────────────────────────────────────────────────────
+const patchConsole = require("../logger/patchConsole");
+const Logger = require("../logger/internal");
+// ── ASCII banner ───────────────────────────────────────────────────────────────
 
 const BANNER_LINES = [
     '  ███╗   ███╗██╗██╗     ██╗      █████╗ ███████╗',
@@ -20,10 +21,9 @@ const BANNER_LINES = [
 
 function printBanner(host, port) {
     const env = process.env.NODE_ENV || 'development';
-    const ver = 'v' + (require('../../package.json').version || '0.1.2');
+    const ver = 'v' + (require('../../package.json').version || '0.1.0');
     const url = `http://${host}:${port}`;
     const hr = chalk.dim('  ' + '─'.repeat(54));
-
     const envColour = env === 'production' ? chalk.red
         : env === 'staging' ? chalk.yellow
             : chalk.green;
@@ -32,52 +32,37 @@ function printBanner(host, port) {
     for (const line of BANNER_LINES) {
         process.stdout.write(chalk.bold.cyan(line) + '\n');
     }
-    process.stdout.write('\n');
-    process.stdout.write(hr + '\n');
+    process.stdout.write('\n' + hr + '\n');
     process.stdout.write(
-        '  ' +
-        chalk.dim(ver.padEnd(8)) +
-        chalk.dim('│') + '  ' +
-        envColour('⬤  ' + env) + '  ' +
-        chalk.dim('│') + '  ' +
-        chalk.bold.white(url) +
-        '\n'
+        '  ' + chalk.dim(ver.padEnd(8)) +
+        chalk.dim('│') + '  ' + envColour('⬤  ' + env) + '  ' +
+        chalk.dim('│') + '  ' + chalk.bold.white(url) + '\n'
     );
     process.stdout.write(hr + '\n\n');
 }
 
-// ── Hot reload watcher ────────────────────────────────────────────────────────
-
-/**
- * Directories watched for changes (relative to project root).
- * Watching parent dirs is enough — fs.watch recursive covers all descendants.
- */
-const WATCH_DIRS = [
-    'app',
-    'routes',
-    'config',
-    'bootstrap',
-    'providers',
-    'middleware',
-];
+// ── Constants ─────────────────────────────────────────────────────────────────
 
-/** File extensions that trigger a reload when changed. */
+const WATCH_DIRS = ['app', 'routes', 'config', 'bootstrap', 'providers', 'middleware'];
 const WATCH_EXTS = new Set(['.js', '.mjs', '.cjs', '.json', '.njk', '.env']);
+const DEBOUNCE_MS = 250;
+
 
-/** How long to wait after the last change before restarting (ms). */
-const DEBOUNCE_MS = 300;
+// ── HotReloader ───────────────────────────────────────────────────────────────
 
 class HotReloader {
-    constructor(bootstrapPath, env) {
+    constructor(bootstrapPath, publicPort, publicHost) {
         this._bootstrap = bootstrapPath;
-        this._cwd = path.dirname(bootstrapPath.replace(/bootstrap.+$/, '')) ||
-            process.cwd();
-        this._env = env;
+        this._initialised = false
+
         this._child = null;
-        this._watchers = [];
-        this._timer = null;
         this._starting = false;
         this._restarts = 0;
+
+        // Queued { req, res, timer } entries while child is restarting
+        this._queue = [];
+        this._watchers = [];
+        this._timer = null;
     }
 
     start() {
@@ -86,75 +71,75 @@ class HotReloader {
         this._handleSignals();
     }
 
-    // ── Child process management ──────────────────────────────────────────────
-
     _spawnChild() {
-        if (this._starting) return;
+        if (this._starting) {
+            return;
+        }
         this._starting = true;
-
+        const extra = {}
+        if (!this._initialised) {
+            extra["MILLAS_START_UP"] = true
+            this._initialised = true
+        }
         this._child = fork(this._bootstrap, [], {
-            env: {...process.env, ...this._env},
-            stdio: 'inherit',    // child shares parent's stdout/stderr — output appears inline
-            // detached: false   — child dies with parent
+            env: {
+                ...extra,
+                MILLAS_CHILD: '1',
+                DEBUG: process.env.APP_DEBUG,
+            },
+            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;
-            // Abnormal exit (crash) — don't auto-restart, let the developer fix it
+
             if (code !== 0 && signal !== 'SIGTERM' && signal !== 'SIGKILL') {
-                process.stdout.write(
-                    '\n' + chalk.red('  ✖  App crashed') +
+                console.error(chalk.red('✖  App crashed') +
                     chalk.dim(` (exit ${code ?? signal})`) +
-                    chalk.dim(' — waiting for changes…\n\n')
+                    chalk.dim(' — fix the error, file watcher will reload…')
                 );
             }
         });
-
-        this._child.on('error', (err) => {
+        //
+        this._child.on('error', err => {
             this._starting = false;
-            process.stderr.write(chalk.red(`\n  ✖  Child error: ${err.message}\n\n`));
+            console.error(chalk.red(`✖  ${err.message}`));
         });
     }
 
     _killChild(cb) {
-        if (!this._child || this._child.exitCode !== null) {
-            cb();
-            return;
-        }
+        if (!this._child || this._child.exitCode !== null) return cb();
         this._child.once('exit', cb);
         this._child.kill('SIGTERM');
-
-        // Force kill if graceful shutdown takes too long
-        setTimeout(() => {
-            if (this._child && this._child.exitCode === null) {
-                this._child.kill('SIGKILL');
-            }
-        }, 3000).unref();
     }
 
     _restart(changedFile) {
-        const rel = changedFile ? path.relative(process.cwd(), changedFile) : '';
         const link = changedFile
-            ? `\x1b]8;;file://${changedFile}\x07${changedFile}\x1b]8;;\x07`
+            ? `\x1b]8;;file://${changedFile}\x07${path.relative(process.cwd(), changedFile)}\x1b]8;;\x07`
             : '';
-
-        process.stdout.write(
-            '\n  ' + chalk.yellow('↺') + '  ' +
+        console.warn(
+            chalk.yellow('↺') + '  ' +
             chalk.white('Reloading') +
-            (link ? '  ' + chalk.cyan(link) : '') +
-            '\n'
+            (link ? chalk.blueBright('  ' + link) : '')
         );
 
         this._restarts++;
-
-        this._killChild(() => {
-            this._spawnChild();
-        });
+        this._killChild(() => this._spawnChild());
     }
 
-    // ── File watching ─────────────────────────────────────────────────────────
+    // ── 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)),
@@ -166,6 +151,9 @@ class HotReloader {
             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) => {
@@ -179,9 +167,7 @@ class HotReloader {
 
     _scheduleRestart(changedFile) {
         clearTimeout(this._timer);
-        this._timer = setTimeout(() => {
-            this._restart(changedFile);
-        }, DEBOUNCE_MS);
+        this._timer = setTimeout(() => this._restart(changedFile), DEBOUNCE_MS);
     }
 
     _stopWatching() {
@@ -194,8 +180,7 @@ class HotReloader {
         this._watchers = [];
     }
 
-
-    // ── Signal handling ───────────────────────────────────────────────────────
+    // ── Signals ───────────────────────────────────────────────────────────────
 
     _handleSignals() {
         const cleanup = () => {
@@ -204,16 +189,14 @@ class HotReloader {
             if (this._child) this._child.kill('SIGTERM');
             process.exit(0);
         };
-
-        process.on('SIGINT', cleanup);
-        process.on('SIGTERM', cleanup);
+        process.once('SIGINT', cleanup);
+        process.once('SIGTERM', cleanup);
     }
 }
 
-// ── Command definition ────────────────────────────────────────────────────────
+// ── Command ────────────────────────────────────────────────────────────────────
 
 module.exports = function (program) {
-
     program
         .command('serve')
         .description('Start the development server with hot reload')
@@ -221,6 +204,8 @@ module.exports = function (program) {
         .option('-h, --host <host>', 'Host to bind to', 'localhost')
         .option('--no-reload', 'Disable hot reload (run once, like production)')
         .action((options) => {
+
+            const restoreAfterPatch = patchConsole(Logger,"SystemOut")
             const appBootstrap = path.resolve(process.cwd(), 'bootstrap/app.js');
 
             if (!fs.existsSync(appBootstrap)) {
@@ -229,51 +214,38 @@ module.exports = function (program) {
                 process.exit(1);
             }
 
+
+            const publicPort = parseInt(options.port, 10) || 3000;
+            const publicHost = options.host || 'localhost';
+
             const env = {
-                MILLAS_PORT: options.port,
-                MILLAS_HOST: options.host,
-                NODE_ENV: process.env.NODE_ENV || 'development',
-                MILLAS_RELOAD: options.reload ? '1' : '0',
+                NODE_ENV: process.env.APP_ENV || 'development',
+                MILLERS_NODE_ENV: true,
+                MILLAS_HOST: publicHost,
+                MILLAS_PORT: String(publicPort),
             };
 
             Object.assign(process.env, env);
+            printBanner(publicHost, publicPort);
 
-            printBanner(options.host, options.port);
-
-            const hotReload = options.reload !== false;
-
-            if (hotReload) {
-                // ── Hot reload mode ──────────────────────────────────────────────────
-                // Parent process watches files. App runs in a child process.
-                // On change: kill child, clear require cache, refork.
-                process.stdout.write(
-                    '  ' + chalk.green('✔') + '  ' +
-                    chalk.dim('Watching for file changes…') +
-                    '\n'
-                );
-
-                const reloader = new HotReloader(appBootstrap, env);
-                reloader.start();
+            if (options.reload !== false) {
 
+                new HotReloader(appBootstrap, publicPort, publicHost).start();
             } else {
-                // ── Single-run mode (--no-reload) ────────────────────────────────────
                 try {
                     require(appBootstrap);
-                } catch (err) {
-                    process.stderr.write(chalk.red(`\n  ✖  Failed to start: ${err.message}\n\n`));
-                    if (process.env.DEBUG) process.stderr.write(chalk.dim(err.stack) + '\n');
-                    process.exit(1);
+                } catch (e) {
+                    console.log("Error starting server: ", +e)
                 }
             }
         });
 
 };
 
-// Exported so other commands (queue:work) can validate the project exists
 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);
     }
-};
+};