millas 0.2.12-beta → 0.2.12-beta-1

package/src/orm/migration/ModelInspector.js

@@ -1,7 +1,7 @@
 'use strict';
 
-const fs        = require('fs-extra');
-const path      = require('path');
+const fs = require('fs-extra');
+const path = require('path');
 const MillasLog = require('../../logger/internal');
 
 /**
@@ -26,267 +26,266 @@ const MillasLog = require('../../logger/internal');
  * Developers only touch model files — never migration files directly.
  */
 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 { files: string[], message: string }
-   */
-  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.' };
+    constructor(modelsPath, migrationsPath, snapshotPath) {
+        this._modelsPath = modelsPath;
+        this._migrationsPath = migrationsPath;
+        this._snapshotPath = snapshotPath || path.join(process.cwd(), '.millas', 'schema.json');
     }
 
-    await fs.ensureDir(this._migrationsPath);
+    /**
+     * Detect changes and generate migration files.
+     * Returns { files: string[], message: string }
+     */
+    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.'};
+        }
 
-    // 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 = [];
+        await fs.ensureDir(this._migrationsPath);
 
-    for (const diff of diffs) {
-      const file = await this._generateMigration(diff, ts);
-      if (file) files.push(file);
-    }
+        // 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, 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('.') && 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 {
-        delete require.cache[require.resolve(fullPath)];
-      } catch { /* path not yet cached — fine */ }
-
-      let exported;
-      try {
-        exported = require(fullPath);
-      } catch (err) {
-        // Skip files that fail to parse / have runtime errors
-        // Log at WARN level — a skipped model is worth knowing about
-        // but shouldn't stop the command. Falls back silently if the
-        // logger hasn't been configured yet (e.g. bare CLI usage).
-        MillasLog.w('makemigrations', `Skipping ${file}: ${err.message}`);
-        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);
-      }
+        // 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).`};
     }
 
-    return schema;
-  }
+    // ─── Model scanning ───────────────────────────────────────────────────────
 
-  /**
-   * 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 [];
+    /**
+     * 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 = {};
 
-    // Direct class export:  module.exports = MyModel
-    if (typeof exported === 'function') return [exported];
+        if (!fs.existsSync(this._modelsPath)) return schema;
 
-    // Named export object:  module.exports = { MyModel, AnotherModel }
-    if (typeof exported === 'object') {
-      return Object.values(exported).filter(v => typeof v === 'function');
-    }
+        const files = fs.readdirSync(this._modelsPath)
+            .filter(f => f.endsWith('.js') && !f.startsWith('.') && f !== 'index.js');
 
-    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        ?? '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,
-      };
+        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 {
+                delete require.cache[require.resolve(fullPath)];
+            } catch { /* path not yet cached — fine */
+            }
+
+            let exported;
+            exported = require(fullPath);
+
+
+            // 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);
+            }
+        }
+
+        return schema;
     }
 
-    return result;
-  }
+    /**
+     * 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 [];
 
-  // ─── Diffing ──────────────────────────────────────────────────────────────
+        // Direct class export:  module.exports = MyModel
+        if (typeof exported === 'function') return [exported];
 
-  _diff(current, snapshot) {
-    const diffs = [];
+        // 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;
+    }
 
-    // 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] });
-      }
+    /**
+     * 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';
     }
 
-    // Dropped tables (model file removed)
-    for (const table of Object.keys(snapshot)) {
-      if (!current[table]) {
-        diffs.push({ type: 'drop_table', table, fields: snapshot[table] });
-      }
+    /**
+     * 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 ?? '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;
     }
 
-    // Column-level changes on existing tables
-    for (const table of Object.keys(current)) {
-      if (!snapshot[table]) continue; // handled above as create_table
+    // ─── Diffing ──────────────────────────────────────────────────────────────
 
-      const curr = current[table];
-      const prev = snapshot[table];
+    _diff(current, snapshot) {
+        const diffs = [];
 
-      // Added columns
-      for (const col of Object.keys(curr)) {
-        if (!prev[col]) {
-          diffs.push({ type: 'add_column', table, column: col, field: curr[col] });
+        // 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]});
+            }
         }
-      }
 
-      // Removed columns
-      for (const col of Object.keys(prev)) {
-        if (!curr[col]) {
-          diffs.push({ type: 'drop_column', table, column: col, field: prev[col] });
+        // Dropped tables (model file removed)
+        for (const table of Object.keys(snapshot)) {
+            if (!current[table]) {
+                diffs.push({type: 'drop_table', table, fields: snapshot[table]});
+            }
         }
-      }
-
-      // Changed columns — compare each attribute individually for stability
-      for (const col of Object.keys(curr)) {
-        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],
-          });
+
+        // Column-level changes on existing tables
+        for (const table of Object.keys(current)) {
+            if (!snapshot[table]) continue; // handled above as create_table
+
+            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, field: prev[col]});
+                }
+            }
+
+            // Changed columns — compare each attribute individually for stability
+            for (const col of Object.keys(curr)) {
+                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],
+                    });
+                }
+            }
         }
-      }
+
+        return diffs;
     }
 
-    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;
+    /**
+     * 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;
     }
-    return true;
-  }
-
-  // ─── Migration generation ─────────────────────────────────────────────────
-
-  async _generateMigration(diff, ts) {
-    const name     = this._diffToName(diff);
-    const fileName = `${ts}_${name}.js`;
-    const filePath = path.join(this._migrationsPath, fileName);
-
-    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 `auto_migration`;
+
+    // ─── Migration generation ─────────────────────────────────────────────────
+
+    async _generateMigration(diff, ts) {
+        const name = this._diffToName(diff);
+        const fileName = `${ts}_${name}.js`;
+        const filePath = path.join(this._migrationsPath, fileName);
+
+        const content = this._renderMigration(diff, name);
+        await fs.writeFile(filePath, content, 'utf8');
+        return fileName;
     }
-  }
 
-  _renderMigration(diff, name) {
-    switch (diff.type) {
+    _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 `auto_migration`;
+        }
+    }
+
+    _renderMigration(diff, name) {
+        switch (diff.type) {
 
-      case 'create_table':
-        return `'use strict';
+            case 'create_table':
+                return `'use strict';
 
 /**
  * Auto-generated migration: ${name}
@@ -306,8 +305,8 @@ ${this._renderColumns(diff.fields)}    });
 };
 `;
 
-      case 'drop_table':
-        return `'use strict';
+            case 'drop_table':
+                return `'use strict';
 
 /**
  * Auto-generated migration: ${name}
@@ -327,8 +326,8 @@ ${this._renderColumns(diff.fields || {})}    });
 };
 `;
 
-      case 'add_column':
-        return `'use strict';
+            case 'add_column':
+                return `'use strict';
 
 /**
  * Auto-generated migration: ${name}
@@ -349,8 +348,8 @@ ${this._renderColumn('      ', diff.column, diff.field)}
 };
 `;
 
-      case 'drop_column':
-        return `'use strict';
+            case 'drop_column':
+                return `'use strict';
 
 /**
  * Auto-generated migration: ${name}
@@ -371,8 +370,8 @@ ${this._renderColumn('      ', diff.column, diff.field)}
 };
 `;
 
-      case 'alter_column':
-        return `'use strict';
+            case 'alter_column':
+                return `'use strict';
 
 /**
  * Auto-generated migration: ${name}
@@ -394,121 +393,121 @@ ${this._renderColumn('      ', diff.column, diff.previous, '.alter()')}
 };
 `;
 
-      default:
-        return `'use strict';\nmodule.exports = { async up(db) {}, async down(db) {} };\n`;
+            default:
+                return `'use strict';\nmodule.exports = { async up(db) {}, async down(db) {} };\n`;
+        }
     }
-  }
 
-  _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';
-  }
-
-  _renderColumn(indent, name, field, suffix = '') {
-    let line;
-
-    switch (field.type) {
-      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}')`;
+    _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';
     }
 
-    if (field.nullable)               line += '.nullable()';
-    else if (field.type !== 'id')     line += '.notNullable()';
+    _renderColumn(indent, name, field, suffix = '') {
+        let line;
 
-    if (field.unique)                 line += '.unique()';
+        switch (field.type) {
+            case 'id':
+                return `${indent}t.increments('${name}')${suffix};`;
 
-    if (field.default !== null && field.default !== undefined) {
-      line += `.defaultTo(${JSON.stringify(field.default)})`;
-    }
+            case 'string':
+                line = `t.string('${name}', ${field.max || 255})`;
+                break;
 
-    if (field.references) {
-      line += `.references('${field.references.column}')` +
-              `.inTable('${field.references.table}')` +
-              `.onDelete('CASCADE')`;
-    }
+            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;
 
-    return `${indent}${line}${suffix};`;
-  }
+            case 'enum':
+                line = `t.enum('${name}', ${JSON.stringify(field.enumValues || [])})`;
+                break;
 
-  // ─── Snapshot ─────────────────────────────────────────────────────────────
+            case 'uuid':
+                line = `t.uuid('${name}')`;
+                break;
 
-  _loadSnapshot() {
-    try {
-      return fs.readJsonSync(this._snapshotPath);
-    } catch {
-      return {};
+            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};`;
     }
-  }
 
-  _saveSnapshot(schema) {
-    fs.ensureDirSync(path.dirname(this._snapshotPath));
-    fs.writeJsonSync(this._snapshotPath, schema, { spaces: 2 });
-  }
+    // ─── Snapshot ─────────────────────────────────────────────────────────────
 
-  // ─── Helpers ──────────────────────────────────────────────────────────────
+    _loadSnapshot() {
+        try {
+            return fs.readJsonSync(this._snapshotPath);
+        } catch {
+            return {};
+        }
+    }
 
-  _timestamp() {
-    return new Date().toISOString().replace(/[-T:.Z]/g, '').slice(0, 14);
-  }
+    _saveSnapshot(schema) {
+        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;