millas 0.2.12-beta → 0.2.12-beta-2

package/src/orm/migration/ModelInspector.js

@@ -1,8 +1,10 @@
 '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');
+const { walkJs, extractClasses, isMillasModel, fieldsEqual } = require('./utils');
+const { normaliseField } = require('./ProjectState');
 
 /**
  * ModelInspector
@@ -26,267 +28,333 @@ 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);
-
-    // 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);
+    /**
+     * The baseline schema that each system migration creates.
+     * Keyed by table name → field definitions (same shape as _extractFields output).
+     *
+     * When makemigrations encounters a system-owned table for the first time
+     * (no snapshot entry yet), it seeds the snapshot from this baseline rather
+     * than from the current model. That ensures any fields the developer added
+     * beyond the baseline are detected as add_column diffs — not silently ignored.
+     *
+     * Keep in sync with src/migrations/system/000*.js.
+     */
+    static get SYSTEM_BASELINES() {
+        // Lazy-load AuthUser so this file has no hard dependency at module load time.
+        // The getter is only called during makeMigrations(), never at require() time.
+        const AuthUser = require('../../auth/AuthUser');
+        const { fields } = require('../fields/index');
+
+        const extractFields = (fieldsMap) => {
+            const result = {};
+            for (const [name, field] of Object.entries(fieldsMap)) {
+                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;
+        };
+
+        return {
+            // system/0001_users.js — mirrors AuthUser.fields exactly
+            users: extractFields(AuthUser.fields),
+
+            // system/0002_admin_log.js
+            millas_admin_log: extractFields({
+                id:         fields.id(),
+                user_id:    fields.integer({ unsigned: true, nullable: true }),
+                user_email: fields.string({ nullable: true }),
+                resource:   fields.string(),
+                record_id:  fields.string({ nullable: true }),
+                action:     fields.enum(['create', 'update', 'delete']),
+                label:      fields.string({ nullable: true }),
+                change_msg: fields.text({ nullable: true }),
+                created_at: fields.timestamp(),
+            }),
+
+            // system/0003_sessions.js
+            millas_sessions: extractFields({
+                session_key: fields.string({ max: 64 }),
+                user_id:     fields.integer({ unsigned: true }),
+                payload:     fields.text({ nullable: true }),
+                ip_address:  fields.string({ max: 45, nullable: true }),
+                user_agent:  fields.string({ max: 512, nullable: true }),
+                expires_at:  fields.timestamp(),
+                created_at:  fields.timestamp(),
+            }),
+
+            // millas_migrations — internal tracking table, not user-accessible
+            millas_migrations: extractFields({
+                id:    fields.id(),
+                name:  fields.string(),
+                pool:  fields.string({ max: 20 }),
+                batch: fields.integer(),
+            }),
+        };
     }
 
-    // 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);
-      }
+    /** Convenience: just the set of system table names. */
+    static get SYSTEM_TABLES() {
+        return new Set(Object.keys(ModelInspector.SYSTEM_BASELINES));
     }
 
-    return schema;
-  }
+    /**
+     * 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.'};
+        }
 
-  /**
-   * 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 [];
+        await fs.ensureDir(this._migrationsPath);
 
-    // Direct class export:  module.exports = MyModel
-    if (typeof exported === 'function') return [exported];
+        // 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 = [];
 
-    // Named export object:  module.exports = { MyModel, AnotherModel }
-    if (typeof exported === 'object') {
-      return Object.values(exported).filter(v => typeof v === 'function');
-    }
+        for (const diff of diffs) {
+            const file = await this._generateMigration(diff, ts);
+            if (file) files.push(file);
+        }
 
-    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,
-      };
+        // 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 result;
-  }
+    // ─── 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 = {};
+        const tableToFile = {}; // track which file owns each table name
+
+        if (!fs.existsSync(this._modelsPath)) return schema;
+
+        const files = walkJs(this._modelsPath);
+
+        for (const fullPath of files) {
+            const file = path.basename(fullPath);
+            const relPath = path.relative(this._modelsPath, fullPath);
+
+            // 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) {
+                // Surface require errors so developers know why a model was skipped.
+                // Common causes: missing dependency, syntax error, bad import path.
+                MillasLog.warn(`[makemigrations] Skipping ${path.relative(this._modelsPath, fullPath)}: ${err.message}`);
+                process.stderr.write(`  ⚠  Could not load model: ${path.relative(this._modelsPath, fullPath)}\n     ${err.message}\n`);
+                continue;
+            }
+
+            // Collect every candidate class from the export
+            const candidates = extractClasses(exported);
+
+            for (const ModelClass of candidates) {
+                if (!isMillasModel(ModelClass)) continue;
+
+                const table = this._resolveTable(ModelClass, file);
+
+                if (tableToFile[table] && tableToFile[table] !== relPath) {
+                    // Same table claimed by two files.
+                    // This is the inheritance pattern: User extends BaseUser, same table.
+                    // Keep the one with MORE fields — that's always the most derived class,
+                    // which has the complete column set for the table.
+                    const existingFieldCount = Object.keys(schema[table] || {}).length;
+                    const newFieldCount      = Object.keys(ModelClass.fields || {}).length;
+
+                    if (newFieldCount > existingFieldCount) {
+                        // New class is more derived — replace
+                        tableToFile[table] = relPath;
+                        schema[table] = this._extractFields(ModelClass.fields);
+                    }
+                    // Otherwise keep the existing (more derived) definition silently.
+                    // No warning — this is expected when extending a base model.
+                } else if (!tableToFile[table]) {
+                    tableToFile[table] = relPath;
+                    schema[table] = this._extractFields(ModelClass.fields);
+                }
+            }
+        }
 
-  // ─── Diffing ──────────────────────────────────────────────────────────────
+        return schema;
+    }
 
-  _diff(current, snapshot) {
-    const diffs = [];
+    /**
+     * Recursively collect all .js files under a directory,
+     * excluding dotfiles and index.js at any depth.
+     */
 
-    // 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 (model file removed)
-    for (const table of Object.keys(snapshot)) {
-      if (!current[table]) {
-        diffs.push({ type: 'drop_table', table, fields: snapshot[table] });
-      }
+    /**
+     * Derive the table name from the model class.
+     * Delegates to utils.resolveTable which respects abstract flag and convention.
+     * fileName fallback kept for backward compat with old snapshot entries.
+     */
+    _resolveTable(ModelClass, fileName) {
+        return resolveTable(ModelClass) ||
+          (fileName ? fileName.replace(/\.js$/, '').toLowerCase() + 's' : null);
     }
 
-    // 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];
+    /**
+     * 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) {
+        // Delegate to normaliseField — single source of truth for field shape.
+        const result = {};
+        for (const [name, field] of Object.entries(fields)) {
+            result[name] = normaliseField(field);
+        }
+        return result;
+    }
 
-      // Added columns
-      for (const col of Object.keys(curr)) {
-        if (!prev[col]) {
-          diffs.push({ type: 'add_column', table, column: col, field: curr[col] });
+    // ─── Diffing ──────────────────────────────────────────────────────────────
+
+    _diff(current, snapshot) {
+        const diffs = [];
+
+        // New tables (model added / first run)
+        for (const table of Object.keys(current)) {
+            if (!snapshot[table]) {
+                if (ModelInspector.SYSTEM_TABLES.has(table)) {
+                    // System table — already created by a system migration.
+                    // Seed the snapshot from the KNOWN SYSTEM BASELINE (what the
+                    // migration actually created), NOT from the current model.
+                    // This ensures any extra fields the developer added beyond the
+                    // baseline are detected as add_column diffs below.
+                    snapshot[table] = ModelInspector.SYSTEM_BASELINES[table] || current[table];
+                } else {
+                    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)
+        // Never generate drop_table for system tables — they are managed by
+        // system migrations, not by user model files.
+        for (const table of Object.keys(snapshot)) {
+            if (!current[table] && !ModelInspector.SYSTEM_TABLES.has(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 (!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.
+     */
+
+
+    // ─── 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;
     }
-    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`;
+
+    _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) {
+    _renderMigration(diff, name) {
+        switch (diff.type) {
 
-      case 'create_table':
-        return `'use strict';
+            case 'create_table':
+                return `'use strict';
 
 /**
  * Auto-generated migration: ${name}
@@ -306,8 +374,8 @@ ${this._renderColumns(diff.fields)}    });
 };
 `;
 
-      case 'drop_table':
-        return `'use strict';
+            case 'drop_table':
+                return `'use strict';
 
 /**
  * Auto-generated migration: ${name}
@@ -327,8 +395,8 @@ ${this._renderColumns(diff.fields || {})}    });
 };
 `;
 
-      case 'add_column':
-        return `'use strict';
+            case 'add_column':
+                return `'use strict';
 
 /**
  * Auto-generated migration: ${name}
@@ -349,8 +417,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 +439,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 +462,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;
+
+            case 'enum':
+                line = `t.enum('${name}', ${JSON.stringify(field.enumValues || [])})`;
+                break;
+
+            case 'uuid':
+                line = `t.uuid('${name}')`;
+                break;
 
-    return `${indent}${line}${suffix};`;
-  }
+            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 ─────────────────────────────────────────────────────────────
+    // ─── Snapshot ─────────────────────────────────────────────────────────────
 
-  _loadSnapshot() {
-    try {
-      return fs.readJsonSync(this._snapshotPath);
-    } catch {
-      return {};
+    _loadSnapshot() {
+        try {
+            return fs.readJsonSync(this._snapshotPath);
+        } catch {
+            return {};
+        }
     }
-  }
 
-  _saveSnapshot(schema) {
-    fs.ensureDirSync(path.dirname(this._snapshotPath));
-    fs.writeJsonSync(this._snapshotPath, schema, { spaces: 2 });
-  }
+    _saveSnapshot(schema) {
+        fs.ensureDirSync(path.dirname(this._snapshotPath));
+        fs.writeJsonSync(this._snapshotPath, schema, {spaces: 2});
+    }
 
-  // ─── Helpers ──────────────────────────────────────────────────────────────
+    // ─── Helpers ──────────────────────────────────────────────────────────────
 
-  _timestamp() {
-    return new Date().toISOString().replace(/[-T:.Z]/g, '').slice(0, 14);
-  }
+    _timestamp() {
+        return new Date().toISOString().replace(/[-T:.Z]/g, '').slice(0, 14);
+    }
 }
 
-module.exports = ModelInspector;
+module.exports = ModelInspector;