millas 0.2.19 → 0.2.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "millas",
-  "version": "0.2.19",
+  "version": "0.2.21",
   "description": "A modern batteries-included backend framework for Node.js — built on Express, inspired by Laravel, Django, and FastAPI",
   "main": "src/index.js",
   "exports": {

package/src/admin/QueryEngine.js

@@ -145,7 +145,7 @@ class QueryEngine {
     // ── Execute data + count in parallel ──────────────────────────────────
     const [rows, countResult] = await Promise.all([
       q.clone().limit(limit).offset(offset),
-      q.clone().count('* as count').first(),
+      q.clone().clearOrder().clearSelect().count('* as count').first(),
     ]);
 
     const total = Number(countResult?.count ?? 0);
@@ -231,12 +231,12 @@ class QueryEngine {
       case 'in':           return q.whereIn(col, Array.isArray(value) ? value : [value]);
       case 'notin':        return q.whereNotIn(col, Array.isArray(value) ? value : [value]);
       case 'between':      return q.whereBetween(col, Array.isArray(value) ? value : [value, value]);
-      case 'contains':
-      case 'icontains':    return q.where(col, 'like', `%${value}%`);
-      case 'startswith':
-      case 'istartswith':  return q.where(col, 'like', `${value}%`);
-      case 'endswith':
-      case 'iendswith':    return q.where(col, 'like', `%${value}`);
+      case 'contains':     return q.where(col, 'like', `%${value}%`);
+      case 'icontains':    return q.where(q.client?.config?.client?.includes('pg') ? col : col, q.client?.config?.client?.includes('pg') ? 'ilike' : 'like', `%${value}%`);
+      case 'startswith':   return q.where(col, 'like', `${value}%`);
+      case 'istartswith':  return q.where(col, q.client?.config?.client?.includes('pg') ? 'ilike' : 'like', `${value}%`);
+      case 'endswith':     return q.where(col, 'like', `%${value}`);
+      case 'iendswith':    return q.where(col, q.client?.config?.client?.includes('pg') ? 'ilike' : 'like', `%${value}`);
       default:             return q.where(key, value);
     }
   }
@@ -246,15 +246,19 @@ class QueryEngine {
    * Uses strftime for SQLite/MySQL; falls back gracefully on PostgreSQL.
    */
   _applyDateHierarchy(q, col, year, month) {
+    const client = q.client?.config?.client || 'sqlite3';
+    const isPg   = client.includes('pg') || client.includes('postgres');
+    const isMy   = client.includes('mysql') || client.includes('maria');
+
     if (year) {
-      try {
-        q = q.whereRaw(`strftime('%Y', \`${col}\`) = ?`, [String(year)]);
-      } catch { /* PG fallback — skip */ }
+      if (isPg)      q = q.whereRaw(`EXTRACT(YEAR FROM "${col}") = ?`, [Number(year)]);
+      else if (isMy) q = q.whereRaw(`YEAR(\`${col}\`) = ?`, [Number(year)]);
+      else           q = q.whereRaw(`strftime('%Y', \`${col}\`) = ?`, [String(year)]);
     }
     if (month) {
-      try {
-        q = q.whereRaw(`strftime('%m', \`${col}\`) = ?`, [String(month).padStart(2, '0')]);
-      } catch { /* PG fallback — skip */ }
+      if (isPg)      q = q.whereRaw(`EXTRACT(MONTH FROM "${col}") = ?`, [Number(month)]);
+      else if (isMy) q = q.whereRaw(`MONTH(\`${col}\`) = ?`, [Number(month)]);
+      else           q = q.whereRaw(`strftime('%m', \`${col}\`) = ?`, [String(month).padStart(2, '0')]);
     }
     return q;
   }

package/src/cli.js

@@ -1,5 +1,8 @@
 'use strict';
 
+// Load .env before anything else so all commands have access to env vars
+require('dotenv').config();
+
 const { Command } = require('commander');
 const chalk = require('chalk');
 const program = new Command();

package/src/commands/migrate.js

@@ -34,8 +34,22 @@ module.exports = function (program) {
             // Match Django's +/-/~ prefix style exactly
             let prefix, label;
             switch (op.type) {
-              case 'CreateModel':
-                prefix = chalk.green('+'); label = `Create model ${op.table}`; break;
+              case 'CreateModel': {
+                const idxLines = [];
+                for (const idx of (op.indexes || [])) {
+                  const l = idx.name
+                    ? `${idx.name} on ${op.table}`
+                    : `on field(s) ${idx.fields.join(', ')} of model ${op.table}`;
+                  idxLines.push(`      ${chalk.green('+')} Create index ${l}`);
+                }
+                for (const ut of (op.uniqueTogether || [])) {
+                  idxLines.push(`      ${chalk.green('+')} Create constraint on ${op.table} (${ut.join(', ')})`);
+                }
+                prefix = chalk.green('+'); label = `Create model ${op.table}`;
+                console.log(chalk.gray(`      ${prefix} ${label}`));
+                idxLines.forEach(l => console.log(chalk.gray(l)));
+                return; // return from forEach callback
+              }
               case 'DeleteModel':
                 prefix = chalk.red('-');   label = `Delete model ${op.table}`; break;
               case 'AddField':
@@ -48,6 +62,24 @@ module.exports = function (program) {
                 prefix = chalk.yellow('~'); label = `Rename field ${op.oldColumn} on ${op.table} to ${op.newColumn}`; break;
               case 'RenameModel':
                 prefix = chalk.yellow('~'); label = `Rename model ${op.oldTable} to ${op.newTable}`; break;
+              case 'AddIndex': {
+                const idx = op.index;
+                const idxLabel = idx.name
+                  ? `${idx.name} on ${op.table}`
+                  : `on field(s) ${idx.fields.join(', ')} of model ${op.table}`;
+                prefix = chalk.green('+'); label = `Create index ${idxLabel}`; break;
+              }
+              case 'RemoveIndex': {
+                const idx = op.index;
+                const idxLabel = idx.name
+                  ? `${idx.name} from ${op.table}`
+                  : `on field(s) ${idx.fields.join(', ')} of model ${op.table}`;
+                prefix = chalk.red('-');   label = `Remove index ${idxLabel}`; break;
+              }
+              case 'RenameIndex':
+                prefix = chalk.yellow('~'); label = `Rename index ${op.oldName} on ${op.table} to ${op.newName}`; break;
+              case 'AlterUniqueTogether':
+                prefix = chalk.yellow('~'); label = `Alter unique_together on ${op.table}`; break;
               default:
                 prefix = chalk.gray(' ');   label = op.type;
             }

package/src/container/AppInitializer.js

@@ -107,6 +107,13 @@ class AppInitializer {
 
         this._kernel._container.instance('basePath', basePath);
 
+        // ── Static file serving ───────────────────────────────────────────────
+        // Auto-serve each storage disk that has a baseUrl configured.
+        // Mirrors Laravel's public disk serving — zero config required.
+        // e.g. LocalDriver root=storage/uploads baseUrl=/storage
+        //      → GET /storage/avatars/photo.jpg serves the file directly.
+        this._serveStorageDisks(expressApp, basePath);
+
         const coreProviders = this._buildCoreProviders(cfg);
         this._kernel.providers([...coreProviders, ...cfg.providers]);
 
@@ -175,6 +182,42 @@ class AppInitializer {
 
     // ── Internal ───────────────────────────────────────────────────────────────
 
+    _serveStorageDisks(expressApp, basePath) {
+        const express = require('express');
+        const path    = require('path');
+        const fs      = require('fs');
+
+        let storageConfig;
+        try {
+            storageConfig = require(basePath + '/config/storage');
+        } catch {
+            // Fall back to the same defaults StorageServiceProvider uses
+            storageConfig = {
+                default: 'local',
+                disks: {
+                    local:  { driver: 'local', root: 'storage/uploads', baseUrl: '/storage' },
+                    public: { driver: 'local', root: 'public/storage',  baseUrl: '/storage' },
+                },
+            };
+        }
+
+        const seen = new Set(); // avoid mounting the same baseUrl twice
+        for (const [, disk] of Object.entries(storageConfig.disks || {})) {
+            if (!disk.baseUrl || !disk.root) continue;
+            if (seen.has(disk.baseUrl)) continue;
+            seen.add(disk.baseUrl);
+
+            const absRoot = path.isAbsolute(disk.root)
+                ? disk.root
+                : path.join(basePath, disk.root);
+
+            // Ensure the directory exists so express.static doesn't warn
+            fs.mkdirSync(absRoot, { recursive: true });
+
+            expressApp.use(disk.baseUrl, express.static(absRoot));
+        }
+    }
+
     _buildCoreProviders(cfg) {
         const providers = [];
         const load = (p) => {

package/src/core/db.js

@@ -1,9 +1,10 @@
-const {
-    Model,
-    fields
-} = require("../orm");
-const { migrations } = require("../orm/migration/operations");
+const { Model, fields } = require('../orm');
+const { migrations }    = require('../orm/migration/operations');
+const F                 = require('../orm/query/F');
+const Q                 = require('../orm/query/Q');
+const HasMany           = require('../orm/relations/HasMany');
+const BelongsTo         = require('../orm/relations/BelongsTo');
+const HasOne            = require('../orm/relations/HasOne');
+const BelongsToMany     = require('../orm/relations/BelongsToMany');
 
-module.exports = {
-    Model, fields,migrations
-}
+module.exports = { Model, fields, migrations, F, Q, HasMany, BelongsTo, HasOne, BelongsToMany };

package/src/orm/drivers/DatabaseManager.js

@@ -99,6 +99,12 @@ class DatabaseManager {
         });
 
       case 'mysql':
+        try { require('mysql2'); } catch {
+          throw new Error(
+            'MySQL driver not installed.\n' +
+            'Run: npm install mysql2'
+          );
+        }
         return knex({
           client:     'mysql2',
           connection: {
@@ -112,6 +118,12 @@ class DatabaseManager {
         });
 
       case 'postgres':
+        try { require('pg'); } catch {
+          throw new Error(
+            'PostgreSQL driver not installed.\n' +
+            'Run: npm install pg'
+          );
+        }
         return knex({
           client:     'pg',
           connection: {

package/src/orm/fields/index.js

@@ -54,19 +54,10 @@ function _makeModelRef(model) {
     if (model === 'self') return null;
     return () => {
         const path = require('path');
-        const modelsDir = path.join(process.cwd(), 'app', 'models');
         try {
-            return require(path.join(modelsDir, model));
+            const all = require(path.join(process.cwd(), 'app', 'models', 'index.js'));
+            return all[model] ?? null;
         } catch {
-            try {
-                const fs = require('fs');
-                const files = fs.readdirSync(modelsDir);
-                const match = files.find(f =>
-                    f.replace(/\.js$/, '').toLowerCase() === model.toLowerCase()
-                );
-                if (match) return require(path.join(modelsDir, match));
-            } catch {
-            }
             return null;
         }
     };
@@ -126,6 +117,22 @@ const fields = {
         return new FieldDefinition('uuid', options);
     },
 
+    email(options = {}) {
+        return new FieldDefinition('email', { max: 254, ...options });
+    },
+
+    url(options = {}) {
+        return new FieldDefinition('url', { max: 2048, ...options });
+    },
+
+    slug(options = {}) {
+        return new FieldDefinition('slug', { max: 255, ...options });
+    },
+
+    ipAddress(options = {}) {
+        return new FieldDefinition('ipAddress', { max: 45, ...options });
+    },
+
     /**
      * ForeignKey — Django-style.
      *

package/src/orm/migration/Makemigrations.js

@@ -93,7 +93,14 @@ class Makemigrations {
     }
 
     // Strip internal flags before writing
-    ops.forEach(op => { delete op._needsDefault; delete op._madeNullable; });
+    ops.forEach(op => {
+      if (op._destructiveWarning) {
+        process.stderr.write(`\n  ⚠  ${op._destructiveWarning}\n`);
+      }
+      delete op._needsDefault;
+      delete op._madeNullable;
+      delete op._destructiveWarning;
+    });
 
     // ── Step 7: Compute file name and content ────────────────────────────────
     // Detect initial FIRST — isInitial must be known before naming the file
@@ -245,50 +252,48 @@ class Makemigrations {
   _opsToName(ops) {
     if (ops.length === 0) return 'auto';
 
-    // For initial migrations → 'initial'
-    // For single op → descriptive name
-    // For multiple ops → Django style: table_field1_field2 (up to 3 segments)
-
     if (ops.length === 1) {
       const op = ops[0];
       switch (op.type) {
-        // 0001_students        (initial already handled above)
         case 'CreateModel':  return op.table;
-        // 0009_delete_course
         case 'DeleteModel':  return `delete_${op.table}`;
-        // 0004_student_age4
         case 'AddField':     return `${op.table}_${op.column}`;
-        // 0008_remove_student_age8
         case 'RemoveField':  return `remove_${op.table}_${op.column}`;
-        // 0007_alter_student_age8
         case 'AlterField':   return `alter_${op.table}_${op.column}`;
-        // 0006_rename_age7_student_age8
         case 'RenameField':  return `rename_${op.oldColumn}_${op.table}_${op.newColumn}`;
         case 'RenameModel':  return `rename_${op.oldTable}`;
+        case 'AddIndex':     return `${op.table}_${(op.index.name || op.index.fields.join('_'))}_idx`;
+        case 'RemoveIndex':  return `remove_${op.table}_${(op.index.name || op.index.fields.join('_'))}_idx`;
+        case 'AlterUniqueTogether': return `${op.table}_unique_together`;
       }
     }
 
-    // Multiple ops — build Django-style compound name from each op's contribution
-    // 0005_remove_student_age4_student_age7  (Remove + Add)
-    const segments = ops.slice(0, 3).map(op => {
+    // Multiple ops — deduplicate tables, build a compact name
+    // Group by type prefix to avoid repetition
+    const seen   = new Set();
+    const parts  = [];
+    for (const op of ops.slice(0, 3)) {
+      const table = op.table || op.oldTable || 'change';
+      let segment;
       switch (op.type) {
-        case 'CreateModel':  return op.table;
-        case 'DeleteModel':  return `delete_${op.table}`;
-        case 'AddField':     return `${op.table}_${op.column}`;
-        case 'RemoveField':  return `${op.table}_${op.column}`;
-        case 'AlterField':   return `alter_${op.table}_${op.column}`;
-        case 'RenameField':  return `rename_${op.oldColumn}_${op.table}_${op.newColumn}`;
-        default: {
-          const table  = op.table || op.oldTable || 'change';
-          const detail = op.column || op.oldColumn || '';
-          return detail ? `${table}_${detail}` : table;
-        }
+        case 'CreateModel':  segment = table; break;
+        case 'DeleteModel':  segment = `delete_${table}`; break;
+        case 'AddField':     segment = `${table}_${op.column}`; break;
+        case 'RemoveField':  segment = `${table}_${op.column}`; break;
+        case 'AlterField':   segment = `alter_${table}_${op.column}`; break;
+        case 'RenameField':  segment = `rename_${op.oldColumn}_${table}_${op.newColumn}`; break;
+        case 'AddIndex':     segment = `${table}_idx`; break;
+        case 'RemoveIndex':  segment = `${table}_idx`; break;
+        case 'AlterUniqueTogether': segment = `${table}_unique`; break;
+        default:             segment = table;
       }
-    });
-    // Prefix with 'remove_' only when first op is a RemoveField (matches Django)
+      if (!seen.has(segment)) {
+        seen.add(segment);
+        parts.push(segment);
+      }
+    }
     const prefix = ops[0]?.type === 'RemoveField' ? 'remove_' : '';
-    const joined = prefix + segments.join('_');
-    return joined || 'auto';
+    return (prefix + parts.join('_')) || 'auto';
   }
 
   /**

package/src/orm/migration/MigrationWriter.js

@@ -36,6 +36,7 @@
  */
 
 const { fieldsEqual } = require('./utils');
+const { indexName }   = require('./operations/indexes');
 
 const MILLAS_VERSION = (() => {
   try { return require('../../..').version || require('../../../package.json').version; } catch {}
@@ -65,37 +66,44 @@ class MigrationWriter {
     const histSch = historyState.toSchema();
     const currSch = currentState.toSchema();
 
+    // ── helpers to get fields/indexes from new schema shape ──────────────────
+    const getFields        = (s, t) => s[t]?.fields        ?? s[t] ?? {};
+    const getIndexes       = (s, t) => s[t]?.indexes        ?? [];
+    const getUniqueTogether = (s, t) => s[t]?.uniqueTogether ?? [];
+
     // New tables
     const newTableOps = [];
     for (const table of Object.keys(currSch)) {
       if (SYSTEM_TABLES.has(table)) continue;
       if (!histSch[table]) {
-        newTableOps.push({ type: 'CreateModel', table, fields: currSch[table] });
+        newTableOps.push({
+          type:          'CreateModel',
+          table,
+          fields:        getFields(currSch, table),
+          indexes:       getIndexes(currSch, table),
+          uniqueTogether: getUniqueTogether(currSch, table),
+        });
       }
     }
-
-    // Topologically sort new CreateModel ops so that if Post has a FK → users,
-    // CreateModel(users) appears before CreateModel(posts) in the migration file.
-    // Cycles are detected and noted — the two-pass FK creation in Operations.js
-    // handles them safely at migrate time.
     ops.push(...this._sortCreateModels(newTableOps));
 
     // Dropped tables
     for (const table of Object.keys(histSch)) {
       if (SYSTEM_TABLES.has(table)) continue;
       if (!currSch[table]) {
-        ops.push({ type: 'DeleteModel', table, fields: histSch[table] });
+        ops.push({ type: 'DeleteModel', table, fields: getFields(histSch, table) });
       }
     }
 
-    // Column-level changes
+    // Column-level + index-level changes
     for (const table of Object.keys(currSch)) {
       if (SYSTEM_TABLES.has(table)) continue;
       if (!histSch[table]) continue;
 
-      const curr = currSch[table];
-      const prev = histSch[table];
+      const curr = getFields(currSch, table);
+      const prev = getFields(histSch, table);
 
+      // Added columns
       for (const col of Object.keys(curr)) {
         if (!prev[col]) {
           const field = curr[col];
@@ -105,15 +113,62 @@ class MigrationWriter {
                               !!histSch[table];
           ops.push({ type: 'AddField', table, column: col, field, _needsDefault: isDangerous });
         } else if (!this._fieldsEqual(curr[col], prev[col])) {
-          ops.push({ type: 'AlterField', table, column: col, field: curr[col], previousField: prev[col] });
+          const op = { type: 'AlterField', table, column: col, field: curr[col], previousField: prev[col] };
+          // Warn on destructive type changes — same as Django's warning
+          if (this._isDestructiveTypeChange(prev[col].type, curr[col].type)) {
+            op._destructiveWarning =
+              `Warning: changing '${table}.${col}' from ${prev[col].type} to ${curr[col].type} ` +
+              `may cause data loss. Existing data cannot be automatically converted.`;
+          }
+          ops.push(op);
         }
       }
 
+      // Removed columns
       for (const col of Object.keys(prev)) {
         if (!curr[col]) {
           ops.push({ type: 'RemoveField', table, column: col, field: prev[col] });
         }
       }
+
+      // ── Index diffs ────────────────────────────────────────────────────────
+      const currIndexes = getIndexes(currSch, table);
+      const prevIndexes = getIndexes(histSch, table);
+
+      const prevIdxKeys = new Set(prevIndexes.map(i => JSON.stringify(i)));
+      const currIdxKeys = new Set(currIndexes.map(i => JSON.stringify(i)));
+
+      // Detect renames: same fields, different name
+      const addedIdxs   = currIndexes.filter(i => !prevIdxKeys.has(JSON.stringify(i)));
+      const removedIdxs = prevIndexes.filter(i => !currIdxKeys.has(JSON.stringify(i)));
+
+      for (const added of addedIdxs) {
+        const matchingRemoved = removedIdxs.find(
+          r => JSON.stringify(r.fields) === JSON.stringify(added.fields) &&
+               r.unique === added.unique &&
+               r.name !== added.name
+        );
+        if (matchingRemoved) {
+          // It's a rename
+          const oldName = matchingRemoved.name || indexName(table, matchingRemoved.fields, matchingRemoved.unique);
+          const newName = added.name           || indexName(table, added.fields, added.unique);
+          ops.push({ type: 'RenameIndex', table, oldName, newName, fields: added.fields });
+          removedIdxs.splice(removedIdxs.indexOf(matchingRemoved), 1);
+        } else {
+          ops.push({ type: 'AddIndex', table, index: added });
+        }
+      }
+      for (const idx of removedIdxs) {
+        ops.push({ type: 'RemoveIndex', table, index: idx });
+      }
+
+      // ── uniqueTogether diffs ───────────────────────────────────────────────
+      const currUT = getUniqueTogether(currSch, table);
+      const prevUT = getUniqueTogether(histSch, table);
+      if (JSON.stringify(currUT.map(s => [...s].sort()).sort()) !==
+          JSON.stringify(prevUT.map(s => [...s].sort()).sort())) {
+        ops.push({ type: 'AlterUniqueTogether', table, newUnique: currUT, oldUnique: prevUT });
+      }
     }
 
     return ops;
@@ -166,15 +221,22 @@ ${opsCode},
   _renderOp(op) {
     switch (op.type) {
 
-      case 'CreateModel':
+      case 'CreateModel': {
+        const idxCode = op.indexes?.length
+          ? `,\n      indexes: ${JSON.stringify(op.indexes)}`
+          : '';
+        const utCode = op.uniqueTogether?.length
+          ? `,\n      uniqueTogether: ${JSON.stringify(op.uniqueTogether)}`
+          : '';
         return `migrations.CreateModel({\n` +
                `      name: '${this._modelName(op.table)}',\n` +
                `      fields: [\n` +
                Object.entries(op.fields)
                  .map(([col, def]) => `        ['${col}', ${this._renderField(def)}],`)
                  .join('\n') + '\n' +
-               `      ],\n` +
+               `      ]${idxCode}${utCode},\n` +
                `    })`;
+      }
 
       case 'DeleteModel':
         // Django omits fields= — not needed in the migration file
@@ -222,6 +284,32 @@ ${opsCode},
                `      newName: '${op.newTable}',\n` +
                `    })`;
 
+      case 'AddIndex':
+        return `migrations.AddIndex({\n` +
+               `      modelName: '${op.table}',\n` +
+               `      index: ${JSON.stringify(op.index)},\n` +
+               `    })`;
+
+      case 'RemoveIndex':
+        return `migrations.RemoveIndex({\n` +
+               `      modelName: '${op.table}',\n` +
+               `      index: ${JSON.stringify(op.index)},\n` +
+               `    })`;
+
+      case 'RenameIndex':
+        return `migrations.RenameIndex({\n` +
+               `      modelName: '${op.table}',\n` +
+               `      oldName: '${op.oldName}',\n` +
+               `      newName: '${op.newName}',\n` +
+               `    })`;
+
+      case 'AlterUniqueTogether':
+        return `migrations.AlterUniqueTogether({\n` +
+               `      modelName: '${op.table}',\n` +
+               `      newUnique: ${JSON.stringify(op.newUnique)},\n` +
+               `      oldUnique: ${JSON.stringify(op.oldUnique)},\n` +
+               `    })`;
+
       case 'RunSQL':
         return `migrations.RunSQL({\n` +
                `      sql: ${JSON.stringify(op.sql)},\n` +
@@ -458,6 +546,22 @@ ${opsCode},
   }
 
   _fieldsEqual(a, b) { return fieldsEqual(a, b); }
+
+  /**
+   * Returns true when changing from oldType to newType risks data loss.
+   * Mirrors Django's check_for_system_checks / check_for_data_loss logic.
+   */
+  _isDestructiveTypeChange(oldType, newType) {
+    if (oldType === newType) return false;
+    // String-family — safe between each other
+    const stringFamily = new Set(['string', 'text', 'email', 'url', 'slug', 'ipAddress']);
+    if (stringFamily.has(oldType) && stringFamily.has(newType)) return false;
+    // Number-family — safe between each other (widening)
+    const numberFamily = new Set(['integer', 'bigInteger', 'float', 'decimal']);
+    if (numberFamily.has(oldType) && numberFamily.has(newType)) return false;
+    // Everything else is potentially destructive
+    return true;
+  }
 }
 
 module.exports = MigrationWriter;

package/src/orm/migration/ModelInspector.js

@@ -484,6 +484,10 @@ ${this._renderColumn('      ', diff.column, diff.previous, '.alter()')}
                 return `${indent}t.increments('${name}')${suffix};`;
 
             case 'string':
+            case 'email':
+            case 'url':
+            case 'slug':
+            case 'ipAddress':
                 line = `t.string('${name}', ${field.max || 255})`;
                 break;
 

package/src/orm/migration/ModelScanner.js

@@ -84,8 +84,10 @@ class ModelScanner {
 
     // 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);
+      const fields        = this._resolveFields(cls, classes, tableToClass);
+      const indexes       = cls.indexes       || [];
+      const uniqueTogether = cls.uniqueTogether || [];
+      state.createModel(table, fields, indexes, uniqueTogether);
     }
 
     return state;
@@ -162,7 +164,7 @@ class ModelScanner {
 
 
   _resolveFields(cls, allClasses, tableToClass) {
-    const fields = {};
+    let fields = {};
 
     // Walk the prototype chain collecting fields, child overrides parent
     const chain = this._inheritanceChain(cls);
@@ -191,10 +193,7 @@ class ModelScanner {
       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;
@@ -203,6 +202,13 @@ class ModelScanner {
       }
     }
 
+    // Auto-inject id if no primary key declared — same as Django
+    const hasPk = Object.values(fields).some(f => f?.type === 'id' || f?.primary === true);
+    if (!hasPk) {
+      const { fields: fieldDefs } = require('../fields/index');
+      fields = { id: normaliseField(fieldDefs.id()), ...fields };
+    }
+
     return fields;
   }