millas 0.2.12-beta-1 → 0.2.13-beta

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;

package/src/orm/migration/SchemaBuilder.js

@@ -1,6 +1,7 @@
 'use strict';
 
-const { FieldDefinition } = require('../fields');
+const { applyColumn } = require('./operations/column');
+const { normaliseField } = require('./ProjectState');
 
 /**
  * SchemaBuilder
@@ -27,7 +28,7 @@ class SchemaBuilder {
     const fields = ModelClass.fields;
 
     await this._db.schema.createTable(table, (t) => {
-      this._applyFields(t, fields, ModelClass);
+      this._applyFields(t, fields);
     });
   }
 
@@ -87,87 +88,13 @@ class SchemaBuilder {
 
   // ─── Internal ─────────────────────────────────────────────────────────────
 
-  _applyFields(tableBuilder, fields, ModelClass) {
+  // Delegates to operations/column.js applyColumn — single source of truth
+  // for the type → knex column builder mapping.
+  _applyFields(tableBuilder, fields) {
     for (const [name, field] of Object.entries(fields)) {
-      this._applyField(tableBuilder, name, field, ModelClass);
-    }
-  }
-
-  _applyField(t, name, field) {
-    let col;
-
-    switch (field.type) {
-      case 'id':
-        t.increments(name);
-        return;
-
-      case 'string':
-        col = t.string(name, field.max || 255);
-        break;
-
-      case 'text':
-        col = t.text(name);
-        break;
-
-      case 'integer':
-        col = field.unsigned ? t.integer(name).unsigned() : t.integer(name);
-        break;
-
-      case 'bigInteger':
-        col = field.unsigned ? t.bigInteger(name).unsigned() : t.bigInteger(name);
-        break;
-
-      case 'float':
-        col = t.float(name);
-        break;
-
-      case 'decimal':
-        col = t.decimal(name, field.precision || 8, field.scale || 2);
-        break;
-
-      case 'boolean':
-        col = t.boolean(name);
-        break;
-
-      case 'json':
-        col = t.json(name);
-        break;
-
-      case 'date':
-        col = t.date(name);
-        break;
-
-      case 'timestamp':
-        col = t.timestamp(name, { useTz: false });
-        break;
-
-      case 'enum':
-        col = t.enum(name, field.enumValues || []);
-        break;
-
-      case 'uuid':
-        col = t.uuid(name);
-        break;
-
-      default:
-        col = t.string(name);
-    }
-
-    if (!col) return;
-
-    if (field.nullable)               col = col.nullable();
-    else if (field.type !== 'id')     col = col.notNullable();
-
-    if (field.unique)                 col = col.unique();
-
-    if (field.default !== undefined)  col = col.defaultTo(field.default);
-
-    if (field.references) {
-      col = col.references(field.references.column)
-                .inTable(field.references.table)
-                .onDelete('CASCADE');
+      applyColumn(tableBuilder, name, normaliseField(field));
     }
   }
 }
 
-module.exports = SchemaBuilder;
+module.exports = SchemaBuilder;

package/src/orm/migration/operations/base.js

@@ -0,0 +1,57 @@
+'use strict';
+
+/**
+ * BaseOperation
+ *
+ * Abstract base class for all migration operations.
+ *
+ * Every operation must implement:
+ *   applyState(projectState)  — mutate the in-memory ProjectState (no DB touch)
+ *   up(db)                    — apply the change to the live database
+ *   down(db)                  — revert the change from the live database
+ *   toJSON()                  — return a plain serialisable descriptor
+ *
+ * The `type` property is set by each subclass and must match the key used
+ * in the deserialise() registry in registry.js.
+ */
+class BaseOperation {
+  /**
+   * Mutate the in-memory ProjectState.
+   * Called during migration graph replay (makemigrations) — never touches DB.
+   * @param {import('../ProjectState').ProjectState} _state
+   */
+  // eslint-disable-next-line no-unused-vars
+  applyState(_state) {
+    throw new Error(`${this.constructor.name}.applyState() not implemented`);
+  }
+
+  /**
+   * Apply this operation to the live database (forward migration).
+   * @param {import('knex').Knex} _db
+   */
+  // eslint-disable-next-line no-unused-vars
+  async up(_db) {
+    throw new Error(`${this.constructor.name}.up() not implemented`);
+  }
+
+  /**
+   * Revert this operation from the live database (rollback).
+   * @param {import('knex').Knex} _db
+   */
+  // eslint-disable-next-line no-unused-vars
+  async down(_db) {
+    throw new Error(`${this.constructor.name}.down() not implemented`);
+  }
+
+  /**
+   * Return a plain, JSON-serialisable descriptor for this operation.
+   * Used by MigrationWriter to write migration files and by MigrationGraph
+   * to reload them via deserialise().
+   * @returns {object}
+   */
+  toJSON() {
+    throw new Error(`${this.constructor.name}.toJSON() not implemented`);
+  }
+}
+
+module.exports = { BaseOperation };