millas 0.1.7 → 0.1.9

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