millas 0.2.12-beta → 0.2.12-beta-2

package/src/orm/migration/ModelScanner.js

@@ -0,0 +1,225 @@
+'use strict';
+
+const fs   = require('fs-extra');
+const path = require('path');
+const { ProjectState, normaliseField } = require('./ProjectState');
+const { walkJs, extractClasses, isMillasModel, resolveTable } = require('./utils');
+
+/**
+ * ModelScanner
+ *
+ * Scans model files from disk and builds a ProjectState representing
+ * the CURRENT state of the schema as defined in source code.
+ *
+ * This is the "current state" that makemigrations diffs against the
+ * "reconstructed state" from migration files.
+ *
+ * ── Model loading convention ──────────────────────────────────────────────────
+ *
+ * Models are loaded from a single entry point — app/models/index.js —
+ * which must export all models as named exports:
+ *
+ *   // app/models/index.js
+ *   module.exports = { User, Post, Comment, Order };
+ *
+ * This mirrors Django's pattern where each app's models/__init__.py
+ * explicitly imports and exposes every model class. The developer
+ * decides what is registered — ModelScanner never auto-discovers files.
+ *
+ * Sub-folders are supported as long as index.js re-exports everything:
+ *
+ *   // app/models/index.js
+ *   const { User }    = require('./auth/User');
+ *   const { Post }    = require('./content/Post');
+ *   module.exports    = { User, Post };
+ *
+ * ── Inheritance handling ──────────────────────────────────────────────────────
+ *
+ *   Abstract Base Class (static abstract = true):
+ *     - No table created
+ *     - Fields merged into every concrete subclass
+ *
+ *   Multi-table Inheritance (different static table from parent):
+ *     - Parent gets its own table (already in migration history)
+ *     - Child gets its own table
+ *     - A OneToOne FK from child → parent is auto-injected
+ *
+ *   Same-table inheritance (child overrides fields, same static table):
+ *     - Treated as one model — most-derived fields win
+ *
+ *   Proxy model (static proxy = true):
+ *     - No table created, no migration generated
+ */
+class ModelScanner {
+  constructor(modelsPath) {
+    this._modelsPath = modelsPath;
+  }
+
+  /**
+   * Scan all model files and return a ProjectState.
+   * Never touches the database.
+   */
+  scan() {
+    const state   = new ProjectState();
+    const classes = this._loadAllClasses();
+
+    // Two passes: first register concrete tables, then detect relationships
+    const tableToClass = new Map(); // table → most-derived class
+
+    for (const cls of classes) {
+      // Skip abstract and proxy models — no table
+      // Only skip if the class itself declares abstract/proxy (not inherited)
+      if (cls.hasOwnProperty('abstract') && cls.abstract) continue;
+      if (cls.hasOwnProperty('proxy') && cls.proxy) continue;
+
+      const table = resolveTable(cls);
+      if (!table) continue;
+
+      // Keep the most-derived class for each table
+      const existing = tableToClass.get(table);
+      if (!existing || this._fieldCount(cls) >= this._fieldCount(existing)) {
+        tableToClass.set(table, cls);
+      }
+    }
+
+    // Build state from the canonical (most-derived) class per table
+    for (const [table, cls] of tableToClass) {
+      const fields = this._resolveFields(cls, classes, tableToClass);
+      state.createModel(table, fields);
+    }
+
+    return state;
+  }
+
+  // ─── Internal ─────────────────────────────────────────────────────────────
+
+  /**
+   * Load all model classes from app/models/index.js.
+   *
+   * The index must export all models as named (or default) exports.
+   * ModelScanner never auto-discovers individual files — the developer
+   * controls what is registered, exactly like Django's models/__init__.py.
+   *
+   * Falls back to scanning individual .js files in the models directory
+   * only if index.js does not exist, so existing projects without an
+   * index.js keep working. A warning is printed to encourage migration.
+   */
+  _loadAllClasses() {
+    if (!fs.existsSync(this._modelsPath)) return [];
+
+    const indexPath = path.join(this._modelsPath, 'index.js');
+
+    // ── Primary path: load from index.js ────────────────────────────────
+    if (fs.existsSync(indexPath)) {
+      try { delete require.cache[require.resolve(indexPath)]; } catch {}
+      let exported;
+      try {
+        exported = require(indexPath);
+      } catch (err) {
+        process.stderr.write(
+          `  ✖  [makemigrations] Failed to load app/models/index.js: ${err.message}\n`
+        );
+        return [];
+      }
+      const classes = [];
+      const candidates = extractClasses(exported);
+      for (const cls of candidates) {
+        if (isMillasModel(cls)) classes.push(cls);
+      }
+      return classes;
+    }
+
+    // ── Fallback: walk individual files (legacy — no index.js yet) ───────
+    process.stderr.write(
+      `  ⚠  [makemigrations] No app/models/index.js found. ` +
+      `Create one that exports all your models to follow the recommended pattern.\n` +
+      `  Falling back to file scanning (slower, may miss models in subfolders).\n`
+    );
+
+    const classes = [];
+    const files   = walkJs(this._modelsPath);
+
+    for (const fullPath of files) {
+      try { delete require.cache[require.resolve(fullPath)]; } catch {}
+      let exported;
+      try {
+        exported = require(fullPath);
+      } catch (err) {
+        process.stderr.write(
+          `  ⚠  [makemigrations] Could not load ${path.relative(this._modelsPath, fullPath)}: ${err.message}\n`
+        );
+        continue;
+      }
+      const candidates = extractClasses(exported);
+      for (const cls of candidates) {
+        if (isMillasModel(cls)) classes.push(cls);
+      }
+    }
+
+    return classes;
+  }
+
+
+
+  _resolveFields(cls, allClasses, tableToClass) {
+    const fields = {};
+
+    // Walk the prototype chain collecting fields, child overrides parent
+    const chain = this._inheritanceChain(cls);
+
+    for (const ancestor of chain.reverse()) {
+      // Skip ancestors that have their own table (multi-table inheritance)
+      // unless they are the starting class itself
+      if (ancestor !== cls) {
+        const ancestorTable = resolveTable(ancestor);
+        if (ancestorTable && ancestorTable !== resolveTable(cls)) {
+          // Multi-table: inject OneToOne FK instead of merging fields
+          // The FK column name is `${ancestorTable.replace(/s$/, '')}_ptr`
+          const ptrCol = `${ancestorTable.replace(/s$/, '')}_ptr`;
+          fields[ptrCol] = normaliseField({
+            type:      'integer',
+            unsigned:  true,
+            nullable:  false,
+            unique:    true,
+            references: { table: ancestorTable, column: 'id', onDelete: 'CASCADE' },
+          });
+          continue;
+        }
+      }
+
+      // Merge fields from this ancestor (skip abstract flag, just take fields)
+      if (ancestor.fields && typeof ancestor.fields === 'object') {
+        for (const [name, def] of Object.entries(ancestor.fields)) {
+          if (def && typeof def === 'object' && def.type === 'm2m') continue; // skip M2M
+          // null = explicit removal, like Django's title = None — remove from merged set
+          if (def === null) { delete fields[name]; continue; }
+          // Django convention: ForeignKey declared as 'landlord' creates column 'landlord_id'.
+          // If already ends with _id, use as-is to avoid double-appending.
+          const colName = (def && def._isForeignKey && !name.endsWith('_id'))
+            ? name + '_id'
+            : name;
+          fields[colName] = normaliseField(def);
+        }
+      }
+    }
+
+    return fields;
+  }
+
+  _inheritanceChain(cls) {
+    const chain = [];
+    let current = cls;
+    while (current && current.fields !== undefined) {
+      chain.push(current);
+      current = Object.getPrototypeOf(current);
+    }
+    return chain; // child first, ancestors last
+  }
+
+  _fieldCount(cls) {
+    return cls.fields ? Object.keys(cls.fields).length : 0;
+  }
+
+}
+
+module.exports = ModelScanner;

package/src/orm/migration/ProjectState.js

@@ -0,0 +1,213 @@
+'use strict';
+
+const { tableFromClass, modelNameToTable, isSnakeCase } = require('./utils');
+
+/**
+ * ProjectState
+ *
+ * An in-memory representation of the full database schema at a given point
+ * in migration history. Built by replaying migration operations in order.
+ *
+ * This is the Django-equivalent of ProjectState / ModelState.
+ * It is NEVER derived from the live database — only from migration files.
+ *
+ * Shape:
+ *   state.models = Map<tableName, ModelState>
+ *
+ * ModelState:
+ *   { table, fields: Map<columnName, FieldState>, meta: {} }
+ *
+ * FieldState (plain object, serialisable):
+ *   { type, nullable, unique, default, max, unsigned, enumValues,
+ *     references, precision, scale }
+ */
+class ProjectState {
+  constructor() {
+    // Map<table, { table, fields: Map<name, fieldState> }>
+    this.models = new Map();
+  }
+
+  // ─── Mutation (called by operations during replay) ────────────────────────
+
+  createModel(table, fields) {
+    if (this.models.has(table)) {
+      throw new Error(`ProjectState: table "${table}" already exists`);
+    }
+    const fieldMap = new Map();
+    for (const [name, def] of Object.entries(fields)) {
+      fieldMap.set(name, normaliseField(def));
+    }
+    this.models.set(table, { table, fields: fieldMap });
+  }
+
+  deleteModel(table) {
+    this.models.delete(table);
+  }
+
+  addField(table, column, fieldDef) {
+    const model = this._requireModel(table);
+    if (model.fields.has(column)) {
+      throw new Error(`ProjectState: column "${column}" already exists on "${table}"`);
+    }
+    model.fields.set(column, normaliseField(fieldDef));
+  }
+
+  removeField(table, column) {
+    const model = this._requireModel(table);
+    model.fields.delete(column);
+  }
+
+  alterField(table, column, fieldDef) {
+    const model = this._requireModel(table);
+    model.fields.set(column, normaliseField(fieldDef));
+  }
+
+  renameField(table, oldColumn, newColumn) {
+    const model  = this._requireModel(table);
+    const def    = model.fields.get(oldColumn);
+    if (!def) throw new Error(`ProjectState: column "${oldColumn}" not found on "${table}"`);
+    model.fields.delete(oldColumn);
+    model.fields.set(newColumn, def);
+  }
+
+  renameModel(oldTable, newTable) {
+    const model = this._requireModel(oldTable);
+    this.models.delete(oldTable);
+    model.table = newTable;
+    this.models.set(newTable, model);
+  }
+
+  // ─── Queries ──────────────────────────────────────────────────────────────
+
+  hasTable(table) {
+    return this.models.has(table);
+  }
+
+  getFields(table) {
+    return this._requireModel(table).fields;
+  }
+
+  /** Return a plain-object snapshot of the full state (for diffing). */
+  toSchema() {
+    const schema = {};
+    for (const [table, model] of this.models) {
+      schema[table] = {};
+      for (const [col, def] of model.fields) {
+        schema[table][col] = { ...def };
+      }
+    }
+    return schema;
+  }
+
+  /** Deep clone — used to capture state at a point in time. */
+  clone() {
+    const copy = new ProjectState();
+    for (const [table, model] of this.models) {
+      const fieldMap = new Map();
+      for (const [col, def] of model.fields) {
+        fieldMap.set(col, { ...def });
+      }
+      copy.models.set(table, { table, fields: fieldMap });
+    }
+    return copy;
+  }
+
+  // ─── Internal ─────────────────────────────────────────────────────────────
+
+  _requireModel(table) {
+    const m = this.models.get(table);
+    if (!m) throw new Error(`ProjectState: table "${table}" not found`);
+    return m;
+  }
+}
+
+/**
+ * Normalise a field definition (FieldDefinition instance or plain object)
+ * into a stable plain object for storage in ProjectState.
+ *
+ * Handles both:
+ *   - Legacy foreignId() / raw references object  → references: { table, column, onDelete }
+ *   - Modern ForeignKey() / OneToOne()            → _isForeignKey + _fkModel* resolved here
+ *
+ * For ForeignKey fields, the target table is resolved eagerly from _fkModel so that
+ * the migration system can diff and generate FK constraints correctly.
+ */
+function normaliseField(def) {
+  if (!def) return { type: 'string', nullable: false, unique: false, default: null, max: null, unsigned: false, enumValues: null, references: null, precision: null, scale: null };
+  const type = def.type ?? 'string';
+  const precision = def.precision ?? (type === 'decimal' ? 8 : null);
+  const scale     = def.scale     ?? (type === 'decimal' ? 2 : null);
+
+  // ── Resolve modern ForeignKey / OneToOne references ───────────────────────
+  // fields.ForeignKey() stores metadata in _isForeignKey + _fkModel* rather
+  // than the legacy `references` plain object. Resolve that here so all
+  // downstream code (Operations, SchemaBuilder, MigrationWriter) sees a
+  // uniform `references: { table, column, onDelete }` shape.
+  let references = def.references ?? null;
+  if (def._isForeignKey && !references) {
+    const targetTable = _resolveTargetTable(def._fkModel, def._fkModelRef);
+    if (targetTable) {
+      references = {
+        table:    targetTable,
+        column:   def._fkToField ?? 'id',
+        onDelete: def._fkOnDelete ?? 'CASCADE',
+      };
+    }
+  }
+
+  return {
+    type,
+    nullable:        def.nullable    ?? false,
+    unique:          def.unique       ?? false,
+    default:         def.default !== undefined ? def.default : null,
+    max:             def.max         ?? null,
+    unsigned:        def.unsigned     ?? false,
+    enumValues:      def.enumValues   ?? null,
+    references,
+    precision,
+    scale,
+    // Preserve FK metadata so MigrationWriter can render fields.ForeignKey(...)
+    // instead of a bare fields.integer(...). Stripped from plain objects (migration files).
+    _isForeignKey:   def._isForeignKey  ?? false,
+    _isOneToOne:     def._isOneToOne    ?? false,
+    _fkOnDelete:     def._fkOnDelete    ?? null,
+    _fkRelatedName:  def._fkRelatedName ?? null,
+  };
+}
+
+/**
+ * Resolve a _fkModel / _fkModelRef pair to a table name string.
+ *
+ * _fkModel may be:
+ *   - A Model class (has static .table)
+ *   - A string model name like 'User' or 'self'
+ *   - null / undefined
+ *
+ * _fkModelRef is a lazy () => ModelClass resolver generated by _makeModelRef().
+ */
+/**
+ * Resolve a _fkModel / _fkModelRef pair to a table name string.
+ * Delegates to tableFromClass / modelNameToTable from utils.js.
+ */
+function _resolveTargetTable(fkModel, fkModelRef) {
+  if (fkModel && typeof fkModel === 'function') {
+    const table = tableFromClass(fkModel);
+    if (table) return table;
+  }
+  if (typeof fkModelRef === 'function') {
+    try {
+      const resolved = fkModelRef();
+      if (resolved) {
+        const table = tableFromClass(resolved);
+        if (table) return table;
+      }
+    } catch { /* unresolvable at scan time */ }
+  }
+  if (typeof fkModel === 'string' && fkModel !== 'self') {
+    return isSnakeCase(fkModel) ? fkModel : modelNameToTable(fkModel);
+  }
+  return null;
+}
+
+
+module.exports = { ProjectState, normaliseField };

package/src/orm/migration/RenameDetector.js

@@ -0,0 +1,175 @@
+'use strict';
+
+const readline = require('readline');
+
+/**
+ * RenameDetector
+ *
+ * Detects likely field renames during makemigrations and prompts the developer
+ * to confirm, exactly as Django does:
+ *
+ *   Was student.age4 renamed to student.age7 (a IntegerField)? [y/N]
+ *
+ * ── Algorithm ─────────────────────────────────────────────────────────────────
+ *
+ *  For each table with both RemoveField and AddField ops:
+ *    1. Find pairs where types match
+ *    2. Score similarity (type match required; attribute similarity is a bonus)
+ *    3. Prompt for each candidate, highest-score first
+ *    4. On confirm → replace the Remove+Add pair with a single RenameField
+ *    5. On deny  → keep Remove + Add as separate ops
+ *
+ *  Multiple renames in a single run: each candidate is prompted independently.
+ *  Chained renames across migrations: handled automatically because the history
+ *  state is replayed from all existing migrations, so the "old name" is always
+ *  whatever the field is currently called in the DB.
+ *
+ * ── Matching rules ────────────────────────────────────────────────────────────
+ *
+ *  Required:   same table, same type
+ *  Bonus:      same nullable, same default, same max/precision/enumValues
+ *  No match:   different types (an integer cannot rename to a string)
+ *
+ * ── Non-interactive mode ──────────────────────────────────────────────────────
+ *
+ *  Never prompts. All Remove+Add pairs are kept as-is.
+ *  This matches Django's --no-input behaviour.
+ */
+class RenameDetector {
+  constructor(options = {}) {
+    this._nonInteractive = options.nonInteractive || !process.stdin.isTTY;
+  }
+
+  /**
+   * Given a flat ops list from MigrationWriter.diff(), detect and resolve renames.
+   * Returns a new ops list with confirmed renames replaced by RenameField ops.
+   *
+   * @param {Array<object>} ops
+   * @returns {Promise<Array<object>>}
+   */
+  async detect(ops) {
+    if (this._nonInteractive) return ops;
+
+    // Group RemoveField and AddField by table
+    const removes = ops.filter(op => op.type === 'RemoveField');
+    const adds    = ops.filter(op => op.type === 'AddField');
+
+    if (removes.length === 0 || adds.length === 0) return ops;
+
+    // Build rename candidates: (remove, add) pairs on the same table with same type
+    const candidates = [];
+    for (const rem of removes) {
+      for (const add of adds) {
+        if (rem.table !== add.table) continue;
+        if (rem.field.type !== add.field.type) continue;
+
+        const score = this._similarity(rem.field, add.field);
+        candidates.push({ rem, add, score });
+      }
+    }
+
+    if (candidates.length === 0) return ops;
+
+    // Sort by score descending — highest confidence first
+    candidates.sort((a, b) => b.score - a.score);
+
+    // Track which ops have been consumed by a confirmed rename
+    const consumed = new Set(); // op references
+
+    for (const { rem, add } of candidates) {
+      // Skip if either op was already consumed by a previous rename
+      if (consumed.has(rem) || consumed.has(add)) continue;
+
+      const fieldTypeLabel = this._fieldTypeLabel(rem.field);
+      const confirmed = await this._ask(rem.table, rem.column, add.column, fieldTypeLabel);
+
+      if (confirmed) {
+        consumed.add(rem);
+        consumed.add(add);
+        // Mark for replacement — attach the rename info to the RemoveField op
+        rem._renameToColumn = add.column;
+      }
+    }
+
+    // Rebuild ops list: replace consumed pairs with RenameField, preserve order
+    const result = [];
+    for (const op of ops) {
+      if (consumed.has(op)) {
+        if (op.type === 'RemoveField' && op._renameToColumn) {
+          // Replace Remove with RenameField
+          result.push({
+            type:      'RenameField',
+            table:     op.table,
+            oldColumn: op.column,
+            newColumn: op._renameToColumn,
+          });
+          delete op._renameToColumn;
+        }
+        // Skip the AddField that was consumed — it's been folded into RenameField
+      } else {
+        result.push(op);
+      }
+    }
+
+    return result;
+  }
+
+  // ─── Internals ─────────────────────────────────────────────────────────────
+
+  /**
+   * Score how similar two field definitions are.
+   * Type match is a prerequisite (checked before calling this).
+   * Returns a score 0–5: higher = more likely a rename.
+   */
+  _similarity(a, b) {
+    let score = 1; // base: types match
+    if (a.nullable  === b.nullable)  score++;
+    if (JSON.stringify(a.default)   === JSON.stringify(b.default))  score++;
+    if (a.max       === b.max)       score++;
+    if (JSON.stringify(a.enumValues) === JSON.stringify(b.enumValues)) score++;
+    if (a.unique    === b.unique)    score++;
+    return score;
+  }
+
+  /**
+   * Human-readable field type label — matches Django's "a IntegerField" style.
+   */
+  _fieldTypeLabel(field) {
+    const map = {
+      id:         'AutoField',
+      string:     'CharField',
+      text:       'TextField',
+      integer:    'IntegerField',
+      bigInteger: 'BigIntegerField',
+      float:      'FloatField',
+      decimal:    'DecimalField',
+      boolean:    'BooleanField',
+      json:       'JSONField',
+      date:       'DateField',
+      timestamp:  'DateTimeField',
+      enum:       'CharField',
+      uuid:       'UUIDField',
+    };
+    return map[field.type] || `${field.type}Field`;
+  }
+
+  /**
+   * Prompt:  Was <table>.<oldCol> renamed to <table>.<newCol> (a <Type>)? [y/N]
+   * Returns true if confirmed.
+   */
+  async _ask(table, oldCol, newCol, typeLabel) {
+    return new Promise((resolve) => {
+      const question = `Was ${table}.${oldCol} renamed to ${table}.${newCol} (a ${typeLabel})? [y/N] `;
+      const rl = readline.createInterface({
+        input:  process.stdin,
+        output: process.stdout,
+      });
+      rl.question(question, (answer) => {
+        rl.close();
+        resolve(answer.trim().toLowerCase() === 'y');
+      });
+    });
+  }
+}
+
+module.exports = RenameDetector;