millas 0.1.7 → 0.1.8

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "millas",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "A modern batteries-included backend framework for Node.js — built on Express, inspired by Laravel, Django, and FastAPI",
   "main": "src/index.js",
   "exports": {
-    ".":        "./src/index.js",
-    "./src":    "./src/index.js",
-    "./src/*":  "./src/*.js",
-    "./bin/*":  "./bin/*.js"
+    ".": "./src/index.js",
+    "./src": "./src/index.js",
+    "./src/*": "./src/*.js",
+    "./bin/*": "./bin/*.js"
   },
   "bin": {
     "millas": "./bin/millas.js"
@@ -16,9 +16,20 @@
     "test": "echo \"Run phase-specific tests in tests/\""
   },
   "keywords": [
-    "framework", "express", "orm", "cli", "auth",
-    "queue", "cache", "admin", "mail", "events",
-    "laravel", "django", "fastapi", "millas"
+    "framework",
+    "express",
+    "orm",
+    "cli",
+    "auth",
+    "queue",
+    "cache",
+    "admin",
+    "mail",
+    "events",
+    "laravel",
+    "django",
+    "fastapi",
+    "millas"
   ],
   "author": "Millas Framework",
   "license": "MIT",
@@ -26,22 +37,24 @@
     "node": ">=18.0.0"
   },
   "dependencies": {
-    "bcryptjs":    "3.0.2",
-    "chalk":       "4.1.2",
-    "commander":   "^11.0.0",
-    "fs-extra":    "^11.0.0",
-    "inquirer":    "8.2.6",
-    "jsonwebtoken":"^9.0.3",
-    "knex":        "^3.1.0",
-    "nodemailer":  "^6.9.0",
-    "nunjucks":    "^3.2.4",
-    "ora":         "5.4.1"
+    "bcryptjs": "3.0.2",
+    "chalk": "4.1.2",
+    "commander": "^11.0.0",
+    "fs-extra": "^11.0.0",
+    "inquirer": "8.2.6",
+    "jsonwebtoken": "^9.0.3",
+    "knex": "^3.1.0",
+    "nodemailer": "^6.9.0",
+    "nunjucks": "^3.2.4",
+    "ora": "5.4.1"
   },
   "peerDependencies": {
     "express": "^4.18.0"
   },
   "peerDependenciesMeta": {
-    "express": { "optional": false }
+    "express": {
+      "optional": false
+    }
   },
   "files": [
     "bin/",

package/src/commands/migrate.js

@@ -6,133 +6,185 @@ const fs    = require('fs-extra');
 
 module.exports = function (program) {
 
+  // ── makemigrations ────────────────────────────────────────────────────────
+
   program
     .command('makemigrations')
-    .description('Detect model changes and generate migration files')
+    .description('Scan model files, detect schema changes, generate migration files')
     .action(async () => {
-      const ctx = getProjectContext();
-      const ModelInspector = require('../orm/migration/ModelInspector');
-      const inspector = new ModelInspector(
-        ctx.modelsPath,
-        ctx.migrationsPath,
-        ctx.snapshotPath
-      );
-      const result = await inspector.makeMigrations();
-      if (result.files.length === 0) {
-        console.log(chalk.yellow(`\n  ${result.message}\n`));
-      } else {
-        console.log(chalk.green(`\n  ✔  ${result.message}`));
-        result.files.forEach(f => console.log(chalk.cyan(`     + ${f}`)));
-        console.log();
+      try {
+        const ctx       = getProjectContext();
+        // Fixed: was incorrectly destructured as { ModelInspector }
+        const ModelInspector = require('../orm/migration/ModelInspector');
+        const inspector = new ModelInspector(
+          ctx.modelsPath,
+          ctx.migrationsPath,
+          ctx.snapshotPath,
+        );
+        const result = await inspector.makeMigrations();
+
+        if (result.files.length === 0) {
+          console.log(chalk.yellow(`\n  ${result.message}\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'));
+        }
+      } catch (err) {
+        console.error(chalk.red(`\n  ✖  makemigrations failed: ${err.message}\n`));
+        if (process.env.DEBUG) console.error(err.stack);
+        process.exit(1);
       }
     });
 
+  // ── migrate ───────────────────────────────────────────────────────────────
+
   program
     .command('migrate')
     .description('Run all pending migrations')
     .action(async () => {
-      const runner = await getRunner();
-      const result = await runner.migrate();
-      printMigrationResult(result, 'Ran');
+      try {
+        const runner = await getRunner();
+        const result = await runner.migrate();
+        printResult(result, 'Ran');
+      } catch (err) {
+        bail('migrate', err);
+      }
     });
 
+  // ── migrate:fresh ─────────────────────────────────────────────────────────
+
   program
     .command('migrate:fresh')
-    .description('Drop all tables and re-run all migrations')
+    .description('Drop ALL tables then re-run every migration from scratch')
     .action(async () => {
-      console.log(chalk.yellow('\n  ⚠  Dropping all tables...\n'));
-      const runner = await getRunner();
-      const result = await runner.fresh();
-      printMigrationResult(result, 'Ran');
+      try {
+        console.log(chalk.yellow('\n  ⚠  Dropping all tables…\n'));
+        const runner = await getRunner();
+        const result = await runner.fresh();
+        printResult(result, 'Ran');
+      } catch (err) {
+        bail('migrate:fresh', err);
+      }
     });
 
+  // ── migrate:rollback ──────────────────────────────────────────────────────
+
   program
     .command('migrate:rollback')
     .description('Rollback the last batch of migrations')
     .option('--steps <n>', 'Number of batches to rollback', '1')
     .action(async (options) => {
-      const runner = await getRunner();
-      const result = await runner.rollback(Number(options.steps));
-      printMigrationResult(result, 'Rolled back');
+      try {
+        const runner = await getRunner();
+        const result = await runner.rollback(Number(options.steps));
+        printResult(result, 'Rolled back');
+      } catch (err) {
+        bail('migrate:rollback', err);
+      }
     });
 
+  // ── migrate:reset ─────────────────────────────────────────────────────────
+
   program
     .command('migrate:reset')
-    .description('Rollback all migrations')
+    .description('Rollback ALL migrations')
     .action(async () => {
-      const runner = await getRunner();
-      const result = await runner.reset();
-      printMigrationResult(result, 'Rolled back');
+      try {
+        const runner = await getRunner();
+        const result = await runner.reset();
+        printResult(result, 'Rolled back');
+      } catch (err) {
+        bail('migrate:reset', err);
+      }
     });
 
+  // ── migrate:refresh ───────────────────────────────────────────────────────
+
   program
     .command('migrate:refresh')
-    .description('Rollback all and re-run all migrations')
+    .description('Rollback all then re-run all migrations')
     .action(async () => {
-      const runner = await getRunner();
-      const result = await runner.refresh();
-      printMigrationResult(result, 'Ran');
+      try {
+        const runner = await getRunner();
+        const result = await runner.refresh();
+        printResult(result, 'Ran');
+      } catch (err) {
+        bail('migrate:refresh', err);
+      }
     });
 
+  // ── migrate:status ────────────────────────────────────────────────────────
+
   program
     .command('migrate:status')
-    .description('Show the status of all migrations')
+    .description('Show the status of all migration files')
     .action(async () => {
-      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}`);
+      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();
+      } catch (err) {
+        bail('migrate:status', err);
       }
-      console.log();
     });
 
+  // ── db:seed ───────────────────────────────────────────────────────────────
+
   program
     .command('db:seed')
     .description('Run all database seeders')
     .action(async () => {
-      const ctx = getProjectContext();
-      const seedersDir = ctx.seedersPath;
+      try {
+        const ctx        = getProjectContext();
+        const seedersDir = ctx.seedersPath;
 
-      if (!fs.existsSync(seedersDir)) {
-        console.log(chalk.yellow('\n  No seeders directory found.\n'));
-        return;
-      }
+        if (!fs.existsSync(seedersDir)) {
+          console.log(chalk.yellow('\n  No seeders directory found.\n'));
+          return;
+        }
 
-      const files = fs.readdirSync(seedersDir)
-        .filter(f => f.endsWith('.js') && !f.startsWith('.'))
-        .sort();
+        const files = fs.readdirSync(seedersDir)
+          .filter(f => f.endsWith('.js') && !f.startsWith('.'))
+          .sort();
 
-      if (files.length === 0) {
-        console.log(chalk.yellow('\n  No seeder files found.\n'));
-        return;
-      }
+        if (files.length === 0) {
+          console.log(chalk.yellow('\n  No seeder files found.\n'));
+          return;
+        }
 
-      console.log();
-      for (const file of files) {
-        const seeder = require(path.join(seedersDir, file));
         const db = await getDbConnection();
-        await seeder.run(db);
-        console.log(chalk.green(`  ✔  Seeded: ${file}`));
+        console.log();
+        for (const file of files) {
+          const seeder = require(path.join(seedersDir, file));
+          await seeder.run(db);
+          console.log(chalk.green(`  ✔  Seeded: ${file}`));
+        }
+        console.log();
+      } catch (err) {
+        bail('db:seed', err);
       }
-      console.log();
     });
 };
 
-// ─── Helpers ─────────────────────────────────────────────────────────────────
+// ─── Helpers ──────────────────────────────────────────────────────────────────
 
 function getProjectContext() {
   const cwd = process.cwd();
@@ -149,26 +201,35 @@ async function getDbConnection() {
   if (!fs.existsSync(configPath + '.js')) {
     throw new Error('config/database.js not found. Are you inside a Millas project?');
   }
-  const config = require(configPath);
+  const config         = require(configPath);
   const DatabaseManager = require('../orm/drivers/DatabaseManager');
   DatabaseManager.configure(config);
   return DatabaseManager.connection();
 }
 
 async function getRunner() {
+  // Fixed: was incorrectly destructured as { MigrationRunner }
   const MigrationRunner = require('../orm/migration/MigrationRunner');
   const ctx = getProjectContext();
   const db  = await getDbConnection();
   return new MigrationRunner(db, ctx.migrationsPath);
 }
 
-function printMigrationResult(result, verb) {
+function printResult(result, verb) {
   const list = result.ran || result.rolledBack || [];
   if (list.length === 0) {
     console.log(chalk.yellow(`\n  ${result.message}\n`));
     return;
   }
   console.log(chalk.green(`\n  ✔  ${result.message}`));
-  list.forEach(f => console.log(chalk.cyan(`     ${verb === 'Ran' ? '+' : '-'} ${f}`)));
+  list.forEach(f =>
+    console.log(chalk.cyan(`     ${verb === 'Ran' ? '+' : '-'} ${f}`)),
+  );
   console.log();
 }
+
+function bail(cmd, err) {
+  console.error(chalk.red(`\n  ✖  ${cmd} failed: ${err.message}\n`));
+  if (process.env.DEBUG) console.error(err.stack);
+  process.exit(1);
+}

package/src/orm/migration/MigrationRunner.js

@@ -7,19 +7,19 @@ const path = require('path');
  * MigrationRunner
  *
  * Handles the full migration lifecycle:
- *   - run pending migrations (migrate)
- *   - rollback last batch (migrate:rollback)
- *   - show status table (migrate:status)
- *   - drop all + re-run (migrate:fresh)
- *   - rollback all (migrate:reset)
- *   - rollback all + re-run (migrate:refresh)
+ *   - run pending migrations          (migrate)
+ *   - rollback last batch             (migrate:rollback)
+ *   - show status table               (migrate:status)
+ *   - drop all + re-run               (migrate:fresh)
+ *   - rollback all                    (migrate:reset)
+ *   - rollback all + re-run           (migrate:refresh)
  *
  * Migration history is tracked in the `millas_migrations` table.
  * Each migration file must export { up(db), down(db) }.
  */
 class MigrationRunner {
   /**
-   * @param {object} knexConn   — live knex connection
+   * @param {object} knexConn      — live knex connection
    * @param {string} migrationsPath — absolute path to migrations dir
    */
   constructor(knexConn, migrationsPath) {
@@ -29,9 +29,7 @@ class MigrationRunner {
 
   // ─── Public commands ──────────────────────────────────────────────────────
 
-  /**
-   * Run all pending migrations.
-   */
+  /** Run all pending migrations. */
   async migrate() {
     await this._ensureTable();
     const pending = await this._pending();
@@ -53,9 +51,7 @@ class MigrationRunner {
     return { ran, batch, message: `Ran ${ran.length} migration(s).` };
   }
 
-  /**
-   * Rollback the last batch of migrations.
-   */
+  /** Rollback the last batch of migrations. */
   async rollback(steps = 1) {
     await this._ensureTable();
     const batches = await this._lastBatches(steps);
@@ -66,7 +62,6 @@ class MigrationRunner {
 
     const rolledBack = [];
 
-    // Run in reverse order
     for (const row of [...batches].reverse()) {
       const migration = this._load(row.name);
       await migration.down(this._db);
@@ -77,18 +72,14 @@ class MigrationRunner {
     return { rolledBack, message: `Rolled back ${rolledBack.length} migration(s).` };
   }
 
-  /**
-   * Drop all tables and re-run every migration.
-   */
+  /** Drop all tables and re-run every migration. */
   async fresh() {
     await this._dropAllTables();
     await this._ensureTable();
     return this.migrate();
   }
 
-  /**
-   * Rollback ALL migrations.
-   */
+  /** Rollback ALL migrations. */
   async reset() {
     await this._ensureTable();
     const all = await this._db('millas_migrations').orderBy('id', 'desc');
@@ -108,17 +99,13 @@ class MigrationRunner {
     return { rolledBack, message: `Reset ${rolledBack.length} migration(s).` };
   }
 
-  /**
-   * Rollback all then re-run all.
-   */
+  /** Rollback all then re-run all. */
   async refresh() {
     await this.reset();
     return this.migrate();
   }
 
-  /**
-   * Return status of all migration files.
-   */
+  /** Return status of all migration files. */
   async status() {
     await this._ensureTable();
     const files = this._files();
@@ -127,7 +114,7 @@ class MigrationRunner {
     return files.map(file => ({
       name:   file,
       status: ran.has(file) ? 'Ran' : 'Pending',
-      batch:  ran.get ? ran.get(file) : null,
+      batch:  ran.get(file) || null,
     }));
   }
 
@@ -153,9 +140,7 @@ class MigrationRunner {
 
   async _ranNames() {
     const rows = await this._db('millas_migrations').select('name', 'batch');
-    const map  = new Map(rows.map(r => [r.name, r.batch]));
-    // Map with has() and get()
-    return map;
+    return new Map(rows.map(r => [r.name, r.batch]));
   }
 
   async _nextBatch() {
@@ -168,34 +153,39 @@ class MigrationRunner {
     if (!maxBatch?.max) return [];
 
     const fromBatch = maxBatch.max - steps + 1;
-    // Fetch all then filter in JS to avoid needing >= support in all drivers
     const all = await this._db('millas_migrations').orderBy('id', 'desc');
     return all.filter(r => r.batch >= fromBatch);
   }
 
+  /**
+   * Drop all user tables — dialect-aware.
+   * Resolves the knex client name and delegates to the right helper.
+   */
   async _dropAllTables() {
-    // Get all table names (SQLite compatible)
-    const tables = await this._db
-      .select('name')
-      .from('sqlite_master')
-      .where('type', 'table')
-      .whereNot('name', 'like', 'sqlite_%');
-
-    for (const { name } of tables) {
-      await this._db.schema.dropTableIfExists(name);
+    const clientName = this._db.client.config.client || 'sqlite3';
+
+    let dialect;
+    if (clientName.includes('pg') || clientName.includes('postgres')) {
+      dialect = require('./dialects/postgres');
+    } else if (clientName.includes('mysql') || clientName.includes('maria')) {
+      dialect = require('./dialects/mysql');
+    } else {
+      // Default: sqlite / sqlite3
+      dialect = require('./dialects/sqlite');
     }
+
+    await dialect.dropAllTables(this._db);
   }
 
   _files() {
     if (!fs.existsSync(this._path)) return [];
     return fs.readdirSync(this._path)
       .filter(f => f.endsWith('.js') && !f.startsWith('.'))
-      .sort(); // Sorted by timestamp prefix
+      .sort();
   }
 
   _load(name) {
     const filePath = path.join(this._path, name);
-    // Clear require cache so fresh loads work in tests
     delete require.cache[require.resolve(filePath)];
     const migration = require(filePath);
     if (typeof migration.up !== 'function' || typeof migration.down !== 'function') {

package/src/orm/migration/ModelInspector.js

@@ -6,21 +6,23 @@ const path = require('path');
 /**
  * ModelInspector
  *
- * Implements `millas makemigrations` — Django-style migration generation.
+ * Implements `millas makemigrations` — Django-style auto-migration generation.
  *
  * Workflow:
- *   1. Scan app/models/ for Model subclasses with static fields
+ *   1. Scan app/models/ for Model subclasses that have static `fields`
  *   2. Load the last known schema snapshot (.millas/schema.json)
  *   3. Diff current fields vs snapshot
- *   4. Generate timestamped migration file(s) for each change
- *   5. Update the snapshot
+ *   4. Generate timestamped migration file(s) for each detected change
+ *   5. Update the snapshot so the next run starts clean
  *
  * Detects:
- *   - New tables (model added)
- *   - Dropped tables (model removed)
+ *   - New tables   (model file added)
+ *   - Dropped tables (model file removed)
  *   - Added columns
  *   - Removed columns
- *   - Changed column types
+ *   - Changed column attributes (type, nullable, unique, default, …)
+ *
+ * Developers only touch model files — never migration files directly.
  */
 class ModelInspector {
   constructor(modelsPath, migrationsPath, snapshotPath) {
@@ -31,7 +33,7 @@ class ModelInspector {
 
   /**
    * Detect changes and generate migration files.
-   * Returns an array of generated file paths.
+   * Returns { files: string[], message: string }
    */
   async makeMigrations() {
     const current  = this._scanModels();
@@ -42,54 +44,144 @@ class ModelInspector {
       return { files: [], message: 'No changes detected.' };
     }
 
+    await fs.ensureDir(this._migrationsPath);
+
+    // All diffs in this run share the same timestamp prefix so they sort
+    // together and apply as a logical group.
+    const ts    = this._timestamp();
     const files = [];
+
     for (const diff of diffs) {
-      const file = await this._generateMigration(diff);
+      const file = await this._generateMigration(diff, ts);
       if (file) files.push(file);
     }
 
+    // Persist the new baseline — must happen AFTER generating files so
+    // a crash mid-generation doesn't advance the snapshot prematurely.
     this._saveSnapshot(current);
+
     return { files, message: `Generated ${files.length} migration file(s).` };
   }
 
   // ─── Model scanning ───────────────────────────────────────────────────────
 
+  /**
+   * Walk app/models/ and return a plain-object schema map:
+   *   { tableName: { columnName: { type, nullable, … }, … }, … }
+   *
+   * Handles both default exports (`module.exports = MyModel`) and
+   * named exports (`module.exports = { MyModel }`).
+   */
   _scanModels() {
     const schema = {};
+
     if (!fs.existsSync(this._modelsPath)) return schema;
 
     const files = fs.readdirSync(this._modelsPath)
-      .filter(f => f.endsWith('.js') && !f.startsWith('.'));
+      .filter(f => f.endsWith('.js') && !f.startsWith('.') && f !== 'index.js');
 
     for (const file of files) {
+      const fullPath = path.join(this._modelsPath, file);
+
+      // Always bust require cache so the inspector picks up edits made
+      // in the same process (e.g. during tests).
       try {
-        const ModelClass = require(path.join(this._modelsPath, file));
-        if (!ModelClass || !ModelClass.fields) continue;
+        delete require.cache[require.resolve(fullPath)];
+      } catch { /* path not yet cached — fine */ }
 
-        const table = ModelClass.table || file.replace('.js', '').toLowerCase() + 's';
+      let exported;
+      try {
+        exported = require(fullPath);
+      } catch (err) {
+        // Skip files that fail to parse / have runtime errors
+        process.stderr.write(`  [makemigrations] Skipping ${file}: ${err.message}\n`);
+        continue;
+      }
+
+      // Collect every candidate class from the export
+      const candidates = this._extractClasses(exported);
+
+      for (const ModelClass of candidates) {
+        if (!this._isMillasModel(ModelClass)) continue;
+
+        const table = this._resolveTable(ModelClass, file);
         schema[table] = this._extractFields(ModelClass.fields);
-      } catch {
-        // Skip unloadable models
       }
     }
 
     return schema;
   }
 
+  /**
+   * Given a module export (class, plain object, or anything), return an
+   * array of class/function values that might be Model subclasses.
+   */
+  _extractClasses(exported) {
+    if (!exported) return [];
+
+    // Direct class export:  module.exports = MyModel
+    if (typeof exported === 'function') return [exported];
+
+    // Named export object:  module.exports = { MyModel, AnotherModel }
+    if (typeof exported === 'object') {
+      return Object.values(exported).filter(v => typeof v === 'function');
+    }
+
+    return [];
+  }
+
+  /**
+   * A class qualifies as a Millas Model if:
+   *   - It is a function (class)
+   *   - It has a static `fields` property that is a non-null object
+   *
+   * We intentionally do NOT do `instanceof` checks so the inspector
+   * works even when the user imports Model from a different resolution
+   * path than the one this file was loaded from.
+   */
+  _isMillasModel(cls) {
+    if (typeof cls !== 'function') return false;
+    if (!cls.fields || typeof cls.fields !== 'object') return false;
+    // Must have at least one field
+    return Object.keys(cls.fields).length > 0;
+  }
+
+  /**
+   * Derive the table name from the model class or fall back to the file name.
+   */
+  _resolveTable(ModelClass, fileName) {
+    // Explicitly set static table = '...'
+    if (typeof ModelClass.table === 'string' && ModelClass.table) {
+      return ModelClass.table;
+    }
+    // Convention: file name without extension, pluralised, lowercased
+    return fileName.replace(/\.js$/, '').toLowerCase() + 's';
+  }
+
+  /**
+   * Convert a fields map (whose values may be FieldDefinition instances or
+   * plain objects) into a stable plain-object representation suitable for
+   * snapshot storage and deterministic JSON comparison.
+   */
   _extractFields(fields) {
     const result = {};
+
     for (const [name, field] of Object.entries(fields)) {
+      // Normalise — accept both FieldDefinition instances and plain objects
       result[name] = {
-        type:     field.type,
-        nullable: field.nullable  ?? false,
-        unique:   field.unique    ?? false,
-        default:  field.default   !== undefined ? field.default : null,
-        max:      field.max       ?? null,
-        unsigned: field.unsigned  ?? false,
-        enumValues: field.enumValues ?? null,
-        references: field.references ?? null,
+        type:       field.type        ?? 'string',
+        nullable:   field.nullable    ?? false,
+        unique:     field.unique      ?? false,
+        default:    field.default     !== undefined ? field.default : null,
+        max:        field.max         ?? null,
+        unsigned:   field.unsigned    ?? false,
+        enumValues: field.enumValues  ?? null,
+        references: field.references  ?? null,
+        precision:  field.precision   ?? null,
+        scale:      field.scale       ?? null,
       };
     }
+
     return result;
   }
 
@@ -98,23 +190,23 @@ class ModelInspector {
   _diff(current, snapshot) {
     const diffs = [];
 
-    // New tables
+    // New tables (model added / first run)
     for (const table of Object.keys(current)) {
       if (!snapshot[table]) {
         diffs.push({ type: 'create_table', table, fields: current[table] });
       }
     }
 
-    // Dropped tables
+    // Dropped tables (model file removed)
     for (const table of Object.keys(snapshot)) {
       if (!current[table]) {
-        diffs.push({ type: 'drop_table', table });
+        diffs.push({ type: 'drop_table', table, fields: snapshot[table] });
       }
     }
 
-    // Column changes on existing tables
+    // Column-level changes on existing tables
     for (const table of Object.keys(current)) {
-      if (!snapshot[table]) continue;
+      if (!snapshot[table]) continue; // handled above as create_table
 
       const curr = current[table];
       const prev = snapshot[table];
@@ -129,15 +221,21 @@ class ModelInspector {
       // Removed columns
       for (const col of Object.keys(prev)) {
         if (!curr[col]) {
-          diffs.push({ type: 'drop_column', table, column: col });
+          diffs.push({ type: 'drop_column', table, column: col, field: prev[col] });
         }
       }
 
-      // Changed columns
+      // Changed columns — compare each attribute individually for stability
       for (const col of Object.keys(curr)) {
-        if (!prev[col]) continue;
-        if (JSON.stringify(curr[col]) !== JSON.stringify(prev[col])) {
-          diffs.push({ type: 'alter_column', table, column: col, field: curr[col], previous: prev[col] });
+        if (!prev[col]) continue; // new column — already handled above
+        if (!this._fieldsEqual(curr[col], prev[col])) {
+          diffs.push({
+            type:     'alter_column',
+            table,
+            column:   col,
+            field:    curr[col],
+            previous: prev[col],
+          });
         }
       }
     }
@@ -145,16 +243,25 @@ class ModelInspector {
     return diffs;
   }
 
+  /**
+   * Stable field equality check that ignores key-ordering differences
+   * which can appear when objects are reconstituted from JSON.
+   */
+  _fieldsEqual(a, b) {
+    const keys = new Set([...Object.keys(a), ...Object.keys(b)]);
+    for (const k of keys) {
+      if (JSON.stringify(a[k]) !== JSON.stringify(b[k])) return false;
+    }
+    return true;
+  }
+
   // ─── Migration generation ─────────────────────────────────────────────────
 
-  async _generateMigration(diff) {
+  async _generateMigration(diff, ts) {
     const name     = this._diffToName(diff);
-    const ts       = new Date().toISOString().replace(/[-T:.Z]/g, '').slice(0, 14);
     const fileName = `${ts}_${name}.js`;
     const filePath = path.join(this._migrationsPath, fileName);
 
-    await fs.ensureDir(this._migrationsPath);
-
     const content = this._renderMigration(diff, name);
     await fs.writeFile(filePath, content, 'utf8');
     return fileName;
@@ -167,7 +274,7 @@ class ModelInspector {
       case 'add_column':   return `add_${diff.column}_to_${diff.table}`;
       case 'drop_column':  return `remove_${diff.column}_from_${diff.table}`;
       case 'alter_column': return `alter_${diff.column}_on_${diff.table}`;
-      default:             return `migration_${diff.type}`;
+      default:             return `auto_migration`;
     }
   }
 
@@ -178,8 +285,10 @@ class ModelInspector {
         return `'use strict';
 
 /**
- * Migration: ${name}
- * Auto-generated by: millas makemigrations
+ * Auto-generated migration: ${name}
+ * Created by: millas makemigrations
+ *
+ * DO NOT EDIT — changes to your model will generate a new migration.
  */
 module.exports = {
   async up(db) {
@@ -197,7 +306,8 @@ ${this._renderColumns(diff.fields)}    });
         return `'use strict';
 
 /**
- * Migration: ${name}
+ * Auto-generated migration: ${name}
+ * Created by: millas makemigrations
  */
 module.exports = {
   async up(db) {
@@ -205,11 +315,10 @@ module.exports = {
   },
 
   async down(db) {
-    // Recreate if needed — add column definitions here
+    // Restore the table — regenerate by reverting the model deletion
+    // and running: millas makemigrations
     await db.schema.createTable('${diff.table}', (t) => {
-      t.increments('id');
-      t.timestamps();
-    });
+${this._renderColumns(diff.fields || {})}    });
   },
 };
 `;
@@ -218,7 +327,8 @@ module.exports = {
         return `'use strict';
 
 /**
- * Migration: ${name}
+ * Auto-generated migration: ${name}
+ * Created by: millas makemigrations
  */
 module.exports = {
   async up(db) {
@@ -239,7 +349,8 @@ ${this._renderColumn('      ', diff.column, diff.field)}
         return `'use strict';
 
 /**
- * Migration: ${name}
+ * Auto-generated migration: ${name}
+ * Created by: millas makemigrations
  */
 module.exports = {
   async up(db) {
@@ -250,7 +361,7 @@ module.exports = {
 
   async down(db) {
     await db.schema.table('${diff.table}', (t) => {
-      t.string('${diff.column}').nullable();
+${this._renderColumn('      ', diff.column, diff.field)}
     });
   },
 };
@@ -260,7 +371,8 @@ module.exports = {
         return `'use strict';
 
 /**
- * Migration: ${name}
+ * Auto-generated migration: ${name}
+ * Created by: millas makemigrations
  * Changed: ${JSON.stringify(diff.previous)} → ${JSON.stringify(diff.field)}
  */
 module.exports = {
@@ -284,6 +396,9 @@ ${this._renderColumn('      ', diff.column, diff.previous, '.alter()')}
   }
 
   _renderColumns(fields) {
+    if (!fields || Object.keys(fields).length === 0) {
+      return '      t.increments(\'id\');\n      t.timestamps();\n';
+    }
     return Object.entries(fields)
       .map(([name, field]) => this._renderColumn('      ', name, field))
       .join('\n') + '\n';
@@ -291,30 +406,81 @@ ${this._renderColumn('      ', diff.column, diff.previous, '.alter()')}
 
   _renderColumn(indent, name, field, suffix = '') {
     let line;
+
     switch (field.type) {
-      case 'id':          line = `t.increments('${name}')`;                                    break;
-      case 'string':      line = `t.string('${name}', ${field.max || 255})`;                   break;
-      case 'text':        line = `t.text('${name}')`;                                          break;
-      case 'integer':     line = field.unsigned ? `t.integer('${name}').unsigned()` : `t.integer('${name}')`; break;
-      case 'bigInteger':  line = `t.bigInteger('${name}')`;                                    break;
-      case 'float':       line = `t.float('${name}')`;                                        break;
-      case 'decimal':     line = `t.decimal('${name}', ${field.precision||8}, ${field.scale||2})`; break;
-      case 'boolean':     line = `t.boolean('${name}')`;                                      break;
-      case 'json':        line = `t.json('${name}')`;                                         break;
-      case 'date':        line = `t.date('${name}')`;                                         break;
-      case 'timestamp':   line = `t.timestamp('${name}', { useTz: false })`;                  break;
-      case 'enum':        line = `t.enum('${name}', ${JSON.stringify(field.enumValues||[])})`;break;
-      case 'uuid':        line = `t.uuid('${name}')`;                                         break;
-      default:            line = `t.string('${name}')`;
+      case 'id':
+        return `${indent}t.increments('${name}')${suffix};`;
+
+      case 'string':
+        line = `t.string('${name}', ${field.max || 255})`;
+        break;
+
+      case 'text':
+        line = `t.text('${name}')`;
+        break;
+
+      case 'integer':
+        line = field.unsigned
+          ? `t.integer('${name}').unsigned()`
+          : `t.integer('${name}')`;
+        break;
+
+      case 'bigInteger':
+        line = field.unsigned
+          ? `t.bigInteger('${name}').unsigned()`
+          : `t.bigInteger('${name}')`;
+        break;
+
+      case 'float':
+        line = `t.float('${name}')`;
+        break;
+
+      case 'decimal':
+        line = `t.decimal('${name}', ${field.precision || 8}, ${field.scale || 2})`;
+        break;
+
+      case 'boolean':
+        line = `t.boolean('${name}')`;
+        break;
+
+      case 'json':
+        line = `t.json('${name}')`;
+        break;
+
+      case 'date':
+        line = `t.date('${name}')`;
+        break;
+
+      case 'timestamp':
+        line = `t.timestamp('${name}', { useTz: false })`;
+        break;
+
+      case 'enum':
+        line = `t.enum('${name}', ${JSON.stringify(field.enumValues || [])})`;
+        break;
+
+      case 'uuid':
+        line = `t.uuid('${name}')`;
+        break;
+
+      default:
+        line = `t.string('${name}')`;
     }
 
-    if (field.nullable)                  line += '.nullable()';
-    else if (field.type !== 'id')        line += '.notNullable()';
-    if (field.unique)                    line += '.unique()';
-    if (field.default !== null && field.default !== undefined)
-                                         line += `.defaultTo(${JSON.stringify(field.default)})`;
-    if (field.references)
-      line += `.references('${field.references.column}').inTable('${field.references.table}').onDelete('CASCADE')`;
+    if (field.nullable)               line += '.nullable()';
+    else if (field.type !== 'id')     line += '.notNullable()';
+
+    if (field.unique)                 line += '.unique()';
+
+    if (field.default !== null && field.default !== undefined) {
+      line += `.defaultTo(${JSON.stringify(field.default)})`;
+    }
+
+    if (field.references) {
+      line += `.references('${field.references.column}')` +
+              `.inTable('${field.references.table}')` +
+              `.onDelete('CASCADE')`;
+    }
 
     return `${indent}${line}${suffix};`;
   }
@@ -333,6 +499,12 @@ ${this._renderColumn('      ', diff.column, diff.previous, '.alter()')}
     fs.ensureDirSync(path.dirname(this._snapshotPath));
     fs.writeJsonSync(this._snapshotPath, schema, { spaces: 2 });
   }
+
+  // ─── Helpers ──────────────────────────────────────────────────────────────
+
+  _timestamp() {
+    return new Date().toISOString().replace(/[-T:.Z]/g, '').slice(0, 14);
+  }
 }
 
 module.exports = ModelInspector;

package/src/orm/migration/dialects/mysql.js

@@ -0,0 +1,26 @@
+'use strict';
+
+/**
+ * MySQL / MariaDB — drop all user tables in the active database.
+ */
+async function dropAllTables(db) {
+  const dbName = db.client.config.connection.database;
+
+  const rows = await db
+    .select('TABLE_NAME as name')
+    .from('information_schema.TABLES')
+    .where('TABLE_SCHEMA', dbName)
+    .where('TABLE_TYPE', 'BASE TABLE');
+
+  if (rows.length === 0) return;
+
+  await db.raw('SET FOREIGN_KEY_CHECKS = 0');
+
+  for (const { name } of rows) {
+    await db.schema.dropTableIfExists(name);
+  }
+
+  await db.raw('SET FOREIGN_KEY_CHECKS = 1');
+}
+
+module.exports = { dropAllTables };

package/src/orm/migration/dialects/postgres.js

@@ -0,0 +1,18 @@
+'use strict';
+
+/**
+ * PostgreSQL — drop all user tables in the public schema.
+ */
+async function dropAllTables(db) {
+  const rows = await db
+    .select('tablename')
+    .from('pg_tables')
+    .where('schemaname', 'public');
+
+  if (rows.length === 0) return;
+
+  const names = rows.map(r => `"${r.tablename}"`).join(', ');
+  await db.raw(`DROP TABLE IF EXISTS ${names} CASCADE`);
+}
+
+module.exports = { dropAllTables };

package/src/orm/migration/dialects/sqlite.js

@@ -0,0 +1,24 @@
+'use strict';
+
+/**
+ * SQLite — drop all user tables.
+ * Reads table names from sqlite_master.
+ */
+async function dropAllTables(db) {
+  // Disable FK checks so drops don't fail on references
+  await db.raw('PRAGMA foreign_keys = OFF');
+
+  const tables = await db
+    .select('name')
+    .from('sqlite_master')
+    .where('type', 'table')
+    .whereNot('name', 'like', 'sqlite_%');
+
+  for (const { name } of tables) {
+    await db.schema.dropTableIfExists(name);
+  }
+
+  await db.raw('PRAGMA foreign_keys = ON');
+}
+
+module.exports = { dropAllTables };

package/src/scaffold/templates.js

@@ -66,6 +66,8 @@ storage/logs/*.log
 storage/uploads/*
 !storage/uploads/.gitkeep
 database/database.sqlite
+# Millas migration snapshot — auto-generated, do not commit
+.millas/
 `,
 
     // ─── millas.config.js ─────────────────────────────────────────
@@ -356,17 +358,37 @@ millas make:controller UserController
 
 # Generate a model
 millas make:model User
+\`\`\`
+
+## Database Migrations (Django-style)
+
+Millas handles migrations automatically — you only edit your model files.
+
+\`\`\`bash
+# 1. Edit app/models/User.js — add, remove, or change fields
+# 2. Generate migration files from your changes
+millas makemigrations
 
-# Run migrations
+# 3. Apply pending migrations to the database
 millas migrate
 \`\`\`
 
+Other migration commands:
+
+\`\`\`bash
+millas migrate:status     # Show which migrations have run
+millas migrate:rollback   # Undo the last batch
+millas migrate:fresh      # Drop everything and re-run all migrations
+millas migrate:reset      # Roll back all migrations
+millas migrate:refresh    # Reset + re-run (like fresh but using down() methods)
+\`\`\`
+
 ## Project Structure
 
 \`\`\`
 app/
   controllers/    # HTTP controllers
-  models/         # ORM models
+  models/         # ORM models  ← only file you edit for schema changes
   services/       # Business logic
   middleware/     # HTTP middleware
   jobs/           # Background jobs
@@ -374,13 +396,14 @@ bootstrap/
   app.js          # Application entry point
 config/           # Configuration files
 database/
-  migrations/     # Database migrations
+  migrations/     # Auto-generated — do not edit by hand
   seeders/        # Database seeders
 routes/
   web.js          # Web routes
   api.js          # API routes
 storage/          # Logs, uploads
 providers/        # Service providers
+.millas/          # Migration snapshot (gitignored)
 \`\`\`
 `,
   };