millas 0.1.0

package/src/orm/migration/ModelInspector.js

@@ -0,0 +1,338 @@
+'use strict';
+
+const fs   = require('fs-extra');
+const path = require('path');
+
+/**
+ * ModelInspector
+ *
+ * Implements `millas makemigrations` — Django-style migration generation.
+ *
+ * Workflow:
+ *   1. Scan app/models/ for Model subclasses with 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
+ *
+ * Detects:
+ *   - New tables (model added)
+ *   - Dropped tables (model removed)
+ *   - Added columns
+ *   - Removed columns
+ *   - Changed column types
+ */
+class ModelInspector {
+  constructor(modelsPath, migrationsPath, snapshotPath) {
+    this._modelsPath     = modelsPath;
+    this._migrationsPath = migrationsPath;
+    this._snapshotPath   = snapshotPath || path.join(process.cwd(), '.millas', 'schema.json');
+  }
+
+  /**
+   * Detect changes and generate migration files.
+   * Returns an array of generated file paths.
+   */
+  async makeMigrations() {
+    const current  = this._scanModels();
+    const snapshot = this._loadSnapshot();
+    const diffs    = this._diff(current, snapshot);
+
+    if (diffs.length === 0) {
+      return { files: [], message: 'No changes detected.' };
+    }
+
+    const files = [];
+    for (const diff of diffs) {
+      const file = await this._generateMigration(diff);
+      if (file) files.push(file);
+    }
+
+    this._saveSnapshot(current);
+    return { files, message: `Generated ${files.length} migration file(s).` };
+  }
+
+  // ─── Model scanning ───────────────────────────────────────────────────────
+
+  _scanModels() {
+    const schema = {};
+    if (!fs.existsSync(this._modelsPath)) return schema;
+
+    const files = fs.readdirSync(this._modelsPath)
+      .filter(f => f.endsWith('.js') && !f.startsWith('.'));
+
+    for (const file of files) {
+      try {
+        const ModelClass = require(path.join(this._modelsPath, file));
+        if (!ModelClass || !ModelClass.fields) continue;
+
+        const table = ModelClass.table || file.replace('.js', '').toLowerCase() + 's';
+        schema[table] = this._extractFields(ModelClass.fields);
+      } catch {
+        // Skip unloadable models
+      }
+    }
+
+    return schema;
+  }
+
+  _extractFields(fields) {
+    const result = {};
+    for (const [name, field] of Object.entries(fields)) {
+      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,
+      };
+    }
+    return result;
+  }
+
+  // ─── Diffing ──────────────────────────────────────────────────────────────
+
+  _diff(current, snapshot) {
+    const diffs = [];
+
+    // New tables
+    for (const table of Object.keys(current)) {
+      if (!snapshot[table]) {
+        diffs.push({ type: 'create_table', table, fields: current[table] });
+      }
+    }
+
+    // Dropped tables
+    for (const table of Object.keys(snapshot)) {
+      if (!current[table]) {
+        diffs.push({ type: 'drop_table', table });
+      }
+    }
+
+    // Column changes on existing tables
+    for (const table of Object.keys(current)) {
+      if (!snapshot[table]) continue;
+
+      const curr = current[table];
+      const prev = snapshot[table];
+
+      // Added columns
+      for (const col of Object.keys(curr)) {
+        if (!prev[col]) {
+          diffs.push({ type: 'add_column', table, column: col, field: curr[col] });
+        }
+      }
+
+      // Removed columns
+      for (const col of Object.keys(prev)) {
+        if (!curr[col]) {
+          diffs.push({ type: 'drop_column', table, column: col });
+        }
+      }
+
+      // Changed columns
+      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] });
+        }
+      }
+    }
+
+    return diffs;
+  }
+
+  // ─── Migration generation ─────────────────────────────────────────────────
+
+  async _generateMigration(diff) {
+    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;
+  }
+
+  _diffToName(diff) {
+    switch (diff.type) {
+      case 'create_table': return `create_${diff.table}_table`;
+      case 'drop_table':   return `drop_${diff.table}_table`;
+      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}`;
+    }
+  }
+
+  _renderMigration(diff, name) {
+    switch (diff.type) {
+
+      case 'create_table':
+        return `'use strict';
+
+/**
+ * Migration: ${name}
+ * Auto-generated by: millas makemigrations
+ */
+module.exports = {
+  async up(db) {
+    await db.schema.createTable('${diff.table}', (t) => {
+${this._renderColumns(diff.fields)}    });
+  },
+
+  async down(db) {
+    await db.schema.dropTableIfExists('${diff.table}');
+  },
+};
+`;
+
+      case 'drop_table':
+        return `'use strict';
+
+/**
+ * Migration: ${name}
+ */
+module.exports = {
+  async up(db) {
+    await db.schema.dropTableIfExists('${diff.table}');
+  },
+
+  async down(db) {
+    // Recreate if needed — add column definitions here
+    await db.schema.createTable('${diff.table}', (t) => {
+      t.increments('id');
+      t.timestamps();
+    });
+  },
+};
+`;
+
+      case 'add_column':
+        return `'use strict';
+
+/**
+ * Migration: ${name}
+ */
+module.exports = {
+  async up(db) {
+    await db.schema.table('${diff.table}', (t) => {
+${this._renderColumn('      ', diff.column, diff.field)}
+    });
+  },
+
+  async down(db) {
+    await db.schema.table('${diff.table}', (t) => {
+      t.dropColumn('${diff.column}');
+    });
+  },
+};
+`;
+
+      case 'drop_column':
+        return `'use strict';
+
+/**
+ * Migration: ${name}
+ */
+module.exports = {
+  async up(db) {
+    await db.schema.table('${diff.table}', (t) => {
+      t.dropColumn('${diff.column}');
+    });
+  },
+
+  async down(db) {
+    await db.schema.table('${diff.table}', (t) => {
+      t.string('${diff.column}').nullable();
+    });
+  },
+};
+`;
+
+      case 'alter_column':
+        return `'use strict';
+
+/**
+ * Migration: ${name}
+ * Changed: ${JSON.stringify(diff.previous)} → ${JSON.stringify(diff.field)}
+ */
+module.exports = {
+  async up(db) {
+    await db.schema.table('${diff.table}', (t) => {
+${this._renderColumn('      ', diff.column, diff.field, '.alter()')}
+    });
+  },
+
+  async down(db) {
+    await db.schema.table('${diff.table}', (t) => {
+${this._renderColumn('      ', diff.column, diff.previous, '.alter()')}
+    });
+  },
+};
+`;
+
+      default:
+        return `'use strict';\nmodule.exports = { async up(db) {}, async down(db) {} };\n`;
+    }
+  }
+
+  _renderColumns(fields) {
+    return Object.entries(fields)
+      .map(([name, field]) => this._renderColumn('      ', name, field))
+      .join('\n') + '\n';
+  }
+
+  _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}')`;
+    }
+
+    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};`;
+  }
+
+  // ─── Snapshot ─────────────────────────────────────────────────────────────
+
+  _loadSnapshot() {
+    try {
+      return fs.readJsonSync(this._snapshotPath);
+    } catch {
+      return {};
+    }
+  }
+
+  _saveSnapshot(schema) {
+    fs.ensureDirSync(path.dirname(this._snapshotPath));
+    fs.writeJsonSync(this._snapshotPath, schema, { spaces: 2 });
+  }
+}
+
+module.exports = ModelInspector;

package/src/orm/migration/SchemaBuilder.js

@@ -0,0 +1,173 @@
+'use strict';
+
+const { FieldDefinition } = require('../fields');
+
+/**
+ * SchemaBuilder
+ *
+ * Converts Model.fields definitions into knex schema operations.
+ * Used by the migration system (Phase 6) and DatabaseServiceProvider.
+ *
+ * Usage:
+ *   const sb = new SchemaBuilder(db);
+ *   await sb.createFromModel(User);
+ *   await sb.dropTable('users');
+ *   await sb.tableExists('users');
+ */
+class SchemaBuilder {
+  constructor(knexConnection) {
+    this._db = knexConnection;
+  }
+
+  /**
+   * Create a table from a Model class's static fields definition.
+   */
+  async createFromModel(ModelClass) {
+    const table  = ModelClass.table;
+    const fields = ModelClass.fields;
+
+    await this._db.schema.createTable(table, (t) => {
+      this._applyFields(t, fields, ModelClass);
+    });
+  }
+
+  /**
+   * Create table only if it doesn't exist.
+   */
+  async createFromModelIfNotExists(ModelClass) {
+    const exists = await this.tableExists(ModelClass.table);
+    if (!exists) await this.createFromModel(ModelClass);
+  }
+
+  /**
+   * Drop a table.
+   */
+  async dropTable(tableName) {
+    await this._db.schema.dropTableIfExists(tableName);
+  }
+
+  /**
+   * Check whether a table exists.
+   */
+  async tableExists(tableName) {
+    return this._db.schema.hasTable(tableName);
+  }
+
+  /**
+   * Add a column to an existing table.
+   */
+  async addColumn(tableName, columnName, fieldDef) {
+    await this._db.schema.table(tableName, (t) => {
+      this._applyField(t, columnName, fieldDef);
+    });
+  }
+
+  /**
+   * Drop a column from a table.
+   */
+  async dropColumn(tableName, columnName) {
+    await this._db.schema.table(tableName, (t) => {
+      t.dropColumn(columnName);
+    });
+  }
+
+  /**
+   * Rename a table.
+   */
+  async renameTable(from, to) {
+    await this._db.schema.renameTable(from, to);
+  }
+
+  /**
+   * Return the raw knex schema builder for advanced use.
+   */
+  get schema() {
+    return this._db.schema;
+  }
+
+  // ─── Internal ─────────────────────────────────────────────────────────────
+
+  _applyFields(tableBuilder, fields, ModelClass) {
+    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');
+    }
+  }
+}
+
+module.exports = SchemaBuilder;