millas 0.2.19 → 0.2.21

package/src/orm/migration/ProjectState.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const { tableFromClass, modelNameToTable, isSnakeCase } = require('./utils');
+const { indexName } = require('./operations/indexes');
 
 /**
  * ProjectState
@@ -29,7 +30,7 @@ class ProjectState {
 
   // ─── Mutation (called by operations during replay) ────────────────────────
 
-  createModel(table, fields) {
+  createModel(table, fields, indexes = [], uniqueTogether = []) {
     if (this.models.has(table)) {
       throw new Error(`ProjectState: table "${table}" already exists`);
     }
@@ -37,13 +38,39 @@ class ProjectState {
     for (const [name, def] of Object.entries(fields)) {
       fieldMap.set(name, normaliseField(def));
     }
-    this.models.set(table, { table, fields: fieldMap });
+    this.models.set(table, { table, fields: fieldMap, indexes: [...indexes], uniqueTogether: [...uniqueTogether] });
   }
 
   deleteModel(table) {
     this.models.delete(table);
   }
 
+  addIndex(table, index) {
+    const model = this._requireModel(table);
+    model.indexes = model.indexes || [];
+    model.indexes.push(index);
+  }
+
+  removeIndex(table, index) {
+    const model = this._requireModel(table);
+    model.indexes = (model.indexes || []).filter(
+      i => JSON.stringify(i) !== JSON.stringify(index)
+    );
+  }
+
+  renameIndex(table, oldName, newName) {
+    const model = this._requireModel(table);
+    model.indexes = (model.indexes || []).map(i => {
+      const iName = i.name || indexName(model.table, i.fields, i.unique);
+      return iName === oldName ? { ...i, name: newName } : i;
+    });
+  }
+
+  alterUniqueTogether(table, uniqueTogether) {
+    const model = this._requireModel(table);
+    model.uniqueTogether = uniqueTogether;
+  }
+
   addField(table, column, fieldDef) {
     const model = this._requireModel(table);
     if (model.fields.has(column)) {
@@ -91,9 +118,13 @@ class ProjectState {
   toSchema() {
     const schema = {};
     for (const [table, model] of this.models) {
-      schema[table] = {};
+      schema[table] = {
+        fields:        {},
+        indexes:       model.indexes       || [],
+        uniqueTogether: model.uniqueTogether || [],
+      };
       for (const [col, def] of model.fields) {
-        schema[table][col] = { ...def };
+        schema[table].fields[col] = { ...def };
       }
     }
     return schema;
@@ -107,7 +138,12 @@ class ProjectState {
       for (const [col, def] of model.fields) {
         fieldMap.set(col, { ...def });
       }
-      copy.models.set(table, { table, fields: fieldMap });
+      copy.models.set(table, {
+        table,
+        fields:         fieldMap,
+        indexes:        JSON.parse(JSON.stringify(model.indexes || [])),
+        uniqueTogether: JSON.parse(JSON.stringify(model.uniqueTogether || [])),
+      });
     }
     return copy;
   }

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

@@ -1,81 +1,49 @@
 'use strict';
 
-/**
- * column.js
- *
- * Knex column builder helpers shared across all field-level operations.
- *
- * Having these in one place means:
- *   - The type → knex method mapping is never duplicated
- *   - AlterField reuses the same logic as AddField, with `.alter()` appended
- *   - FK constraint attachment is explicit and separated from column creation
- *
- * Exports:
- *   applyColumn(t, name, def)            — add a new column to a table builder
- *   alterColumn(t, name, def)            — modify an existing column (.alter())
- *   attachFKConstraints(db, table, fields) — attach FK constraints via ALTER TABLE
- *                                           after all tables in a migration exist
- */
-
 // ─── Core column builder ──────────────────────────────────────────────────────
 
-/**
- * Add a single column to a knex table builder.
- *
- * Handles all supported field types, nullability, uniqueness, defaults,
- * and inline FK constraints (references).
- *
- * Pass `{ ...def, references: null }` to suppress FK constraint creation
- * when deferring constraints to a later ALTER TABLE pass.
- *
- * @param {object} t     — knex table builder (from createTable / table callback)
- * @param {string} name  — column name
- * @param {object} def   — normalised field definition from ProjectState.normaliseField()
- */
-function applyColumn(t, name, def) {
+function applyColumn(t, name, def, tableName) {
   const col = _buildColumn(t, name, def);
-  if (!col) return; // 'id' handled internally by _buildColumn
+  if (!col) return;
 
   _applyModifiers(col, def);
+
+  // Postgres enum: stored as text + separate CHECK constraint
+  if (def.type === 'enum' && def.enumValues?.length) {
+    const client = t.client?.config?.client || '';
+    if (client.includes('pg') || client.includes('postgres')) {
+      const values         = def.enumValues.map(v => `'${v}'`).join(', ');
+      const constraintName = `${tableName || 'tbl'}_${name}_check`;
+      t.check(`"${name}" in (${values})`, [], constraintName);
+    }
+  }
 }
 
-/**
- * Modify an existing column in a knex alterTable builder.
- * Identical to applyColumn but appends `.alter()` — required by knex to
- * signal that this is a column modification, not a new column addition.
- *
- * Note: FK constraints are NOT altered here — use attachFKConstraints()
- * to manage them separately. Most DBs require DROP CONSTRAINT + re-add
- * for FK changes, which is safer to do explicitly.
- *
- * @param {object} t     — knex table builder (from alterTable callback)
- * @param {string} name  — column name
- * @param {object} def   — normalised field definition
- */
-function alterColumn(t, name, def) {
+function alterColumn(t, name, def, tableName) {
+  const client = t.client?.config?.client || '';
+  const isPg   = client.includes('pg') || client.includes('postgres');
+
+  if (isPg && def.type === 'enum' && def.enumValues?.length) {
+    // Postgres: ALTER COLUMN TYPE with inline CHECK is invalid.
+    // Drop old CHECK constraint, add new one.
+    const constraintName = `${tableName || 'tbl'}_${name}_check`;
+    const values         = def.enumValues.map(v => `'${v}'`).join(', ');
+    try { t.dropChecks(constraintName); } catch {}
+    t.check(`"${name}" in (${values})`, [], constraintName);
+    if (def.nullable) t.setNullable(name);
+    else              t.dropNullable(name);
+    return;
+  }
+
   const col = _buildColumn(t, name, def, { forAlter: true });
   if (!col) return;
 
-  _applyModifiers(col, def, { skipFK: true }); // FKs not altered inline
+  _applyModifiers(col, def, { skipFK: true });
   col.alter();
 }
 
-/**
- * Attach FK constraints for a set of fields on a table.
- *
- * Called by MigrationRunner AFTER all tables in a migration have been
- * created — this guarantees all referenced tables exist.
- *
- * All FK columns for a given table are batched into a single ALTER TABLE
- * statement, not one per column.
- *
- * @param {import('knex').Knex} db
- * @param {string}  table   — table name
- * @param {object}  fields  — { columnName: normalisedDef, ... }
- */
 async function attachFKConstraints(db, table, fields) {
   const fkEntries = Object.entries(fields).filter(([, def]) => def.references);
-
   if (fkEntries.length === 0) return;
 
   await db.schema.alterTable(table, (t) => {
@@ -91,38 +59,27 @@ async function attachFKConstraints(db, table, fields) {
 
 // ─── Internal helpers ─────────────────────────────────────────────────────────
 
-/**
- * Build a knex column builder for a given field type.
- * Returns null for 'id' fields (handled by t.increments which returns void).
- *
- * @param {object}  t
- * @param {string}  name
- * @param {object}  def
- * @param {object}  [opts]
- * @param {boolean} [opts.forAlter] — if true, skip t.increments (can't alter PK)
- * @returns {object|null} knex column builder
- */
 function _buildColumn(t, name, def, opts = {}) {
   switch (def.type) {
     case 'id':
       if (!opts.forAlter) t.increments(name).primary();
-      return null; // increments() doesn't return a chainable column builder
+      return null;
 
     case 'string':
+    case 'email':
+    case 'url':
+    case 'slug':
+    case 'ipAddress':
       return t.string(name, def.max || 255);
 
     case 'text':
       return t.text(name);
 
     case 'integer':
-      return def.unsigned
-        ? t.integer(name).unsigned()
-        : t.integer(name);
+      return def.unsigned ? t.integer(name).unsigned() : t.integer(name);
 
     case 'bigInteger':
-      return def.unsigned
-        ? t.bigInteger(name).unsigned()
-        : t.bigInteger(name);
+      return def.unsigned ? t.bigInteger(name).unsigned() : t.bigInteger(name);
 
     case 'float':
       return t.float(name);
@@ -142,43 +99,36 @@ function _buildColumn(t, name, def, opts = {}) {
     case 'timestamp':
       return t.timestamp(name, { useTz: false });
 
-    case 'enum':
+    case 'enum': {
+      const client = t.client?.config?.client || '';
+      if (client.includes('pg') || client.includes('postgres')) {
+        // Store as text — CHECK constraint added separately in applyColumn
+        return t.text(name);
+      }
       return t.enu(name, def.enumValues || []);
+    }
 
     case 'uuid':
       return t.uuid(name);
 
     default:
-      return t.string(name); // safe fallback
+      return t.string(name);
   }
 }
 
-/**
- * Apply nullability, uniqueness, default, and FK constraint modifiers
- * to an already-built knex column builder.
- *
- * @param {object}  col           — knex column builder
- * @param {object}  def           — normalised field def
- * @param {object}  [opts]
- * @param {boolean} [opts.skipFK] — skip FK constraint (used by alterColumn)
- */
 function _applyModifiers(col, def, opts = {}) {
-  // Nullability
   if (def.nullable) {
     col.nullable();
   } else if (def.type !== 'id') {
     col.notNullable();
   }
 
-  // Uniqueness
   if (def.unique) col.unique();
 
-  // Default value
   if (def.default !== null && def.default !== undefined) {
     col.defaultTo(def.default);
   }
 
-  // Inline FK constraint — skipped when deferring to attachFKConstraints()
   if (!opts.skipFK && def.references) {
     const ref = def.references;
     col
@@ -188,4 +138,4 @@ function _applyModifiers(col, def, opts = {}) {
   }
 }
 
-module.exports = { applyColumn, alterColumn, attachFKConstraints };
+module.exports = { applyColumn, alterColumn, attachFKConstraints };

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

@@ -53,7 +53,7 @@ class AddField extends BaseOperation {
       await this._safeBackfill(db, def);
     } else {
       await db.schema.table(this.table, (t) => {
-        applyColumn(t, this.column, def);
+        applyColumn(t, this.column, def, this.table);
       });
     }
   }
@@ -94,7 +94,7 @@ class AddField extends BaseOperation {
 
     // Step 1: add as nullable
     await db.schema.table(this.table, (t) => {
-      applyColumn(t, this.column, { ...def, nullable: true, default: null });
+      applyColumn(t, this.column, { ...def, nullable: true, default: null }, this.table);
     });
 
     // Step 2: backfill
@@ -115,7 +115,7 @@ class AddField extends BaseOperation {
 
     // Step 3: tighten to NOT NULL
     await db.schema.alterTable(this.table, (t) => {
-      alterColumn(t, this.column, { ...def, nullable: false });
+      alterColumn(t, this.column, { ...def, nullable: false }, this.table);
     });
   }
 }
@@ -148,7 +148,7 @@ class RemoveField extends BaseOperation {
 
   async down(db) {
     await db.schema.table(this.table, (t) => {
-      applyColumn(t, this.column, normaliseField(this.field));
+      applyColumn(t, this.column, normaliseField(this.field), this.table);
     });
   }
 
@@ -186,13 +186,13 @@ class AlterField extends BaseOperation {
 
   async up(db) {
     await db.schema.alterTable(this.table, (t) => {
-      alterColumn(t, this.column, normaliseField(this.field));
+      alterColumn(t, this.column, normaliseField(this.field), this.table);
     });
   }
 
   async down(db) {
     await db.schema.alterTable(this.table, (t) => {
-      alterColumn(t, this.column, normaliseField(this.previousField));
+      alterColumn(t, this.column, normaliseField(this.previousField), this.table);
     });
   }
 

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

@@ -22,34 +22,17 @@ const { applyColumn, alterColumn,
 const { CreateModel, DeleteModel, RenameModel }    = require('./models');
 const { AddField, RemoveField,
         AlterField, RenameField }                  = require('./fields');
+const { AddIndex, RemoveIndex,
+        AlterUniqueTogether, RenameIndex }           = require('./indexes');
 const { RunSQL }                                   = require('./special');
 const { deserialise, migrations, _tableFromName }  = require('./registry');
 
 module.exports = {
-  // Base
   BaseOperation,
-
-  // Column helpers
-  applyColumn,
-  alterColumn,
-  attachFKConstraints,
-
-  // Table-level ops
-  CreateModel,
-  DeleteModel,
-  RenameModel,
-
-  // Field-level ops
-  AddField,
-  RemoveField,
-  AlterField,
-  RenameField,
-
-  // Escape hatch
+  applyColumn, alterColumn, attachFKConstraints,
+  CreateModel, DeleteModel, RenameModel,
+  AddField, RemoveField, AlterField, RenameField,
+  AddIndex, RemoveIndex, AlterUniqueTogether, RenameIndex,
   RunSQL,
-
-  // Registry
-  deserialise,
-  migrations,
-  _tableFromName,
+  deserialise, migrations, _tableFromName,
 };

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

@@ -0,0 +1,197 @@
+'use strict';
+
+const { BaseOperation } = require('./base');
+
+// ─── helpers ──────────────────────────────────────────────────────────────────
+
+function indexName(table, fields, unique = false) {
+  const fieldPart = fields.map(f => f.replace(/^-/, '')).join('_');
+  return `${table}_${fieldPart}_${unique ? 'unique' : 'index'}`;
+}
+
+function _applyIndex(t, table, idx) {
+  const { fields, name, unique } = idx;
+  const idxName  = name || indexName(table, fields, unique);
+  // Separate plain fields from descending fields (prefixed with '-')
+  const columns  = fields.map(f => f.replace(/^-/, ''));
+  const hasDesc  = fields.some(f => f.startsWith('-'));
+
+  if (unique) {
+    t.unique(columns, { indexName: idxName });
+  } else if (hasDesc) {
+    // knex doesn't support per-column sort direction in t.index() —
+    // use raw for descending indexes
+    const colsSql = fields.map(f =>
+      f.startsWith('-') ? `\`${f.slice(1)}\` DESC` : `\`${f}\``
+    ).join(', ');
+    t.index(columns, idxName); // fallback — knex limitation
+    // Note: true DESC index requires raw SQL; knex wraps it as regular index
+  } else {
+    t.index(columns, idxName);
+  }
+}
+
+// ─── AddIndex ─────────────────────────────────────────────────────────────────
+
+class AddIndex extends BaseOperation {
+  /**
+   * @param {string}   table
+   * @param {object}   index  — { fields, name?, unique? }
+   */
+  constructor(table, index) {
+    super();
+    this.type  = 'AddIndex';
+    this.table = table;
+    this.index = index;
+  }
+
+  applyState(state) {
+    state.addIndex(this.table, this.index);
+  }
+
+  async up(db) {
+    const { fields, name, unique } = this.index;
+    const idxName = name || indexName(this.table, fields, unique);
+    await db.schema.table(this.table, (t) => _applyIndex(t, this.table, this.index));
+  }
+
+  async down(db) {
+    const { fields, name, unique } = this.index;
+    const idxName = name || indexName(this.table, fields, unique);
+    const columns = fields.map(f => f.replace(/^-/, ''));
+    await db.schema.table(this.table, (t) => {
+      if (unique) t.dropUnique(columns, idxName);
+      else        t.dropIndex(columns, idxName);
+    });
+  }
+
+  toJSON() {
+    return { type: 'AddIndex', table: this.table, index: this.index };
+  }
+}
+
+// ─── RemoveIndex ──────────────────────────────────────────────────────────────
+
+class RemoveIndex extends BaseOperation {
+  constructor(table, index) {
+    super();
+    this.type  = 'RemoveIndex';
+    this.table = table;
+    this.index = index;
+  }
+
+  applyState(state) {
+    state.removeIndex(this.table, this.index);
+  }
+
+  async up(db) {
+    const { fields, name, unique } = this.index;
+    const idxName = name || indexName(this.table, fields, unique);
+    const columns = fields.map(f => f.replace(/^-/, ''));
+    await db.schema.table(this.table, (t) => {
+      if (unique) t.dropUnique(columns, idxName);
+      else        t.dropIndex(columns, idxName);
+    });
+  }
+
+  async down(db) {
+    await db.schema.table(this.table, (t) => _applyIndex(t, this.table, this.index));
+  }
+
+  toJSON() {
+    return { type: 'RemoveIndex', table: this.table, index: this.index };
+  }
+}
+
+// ─── AlterUniqueTogether ──────────────────────────────────────────────────────
+
+class AlterUniqueTogether extends BaseOperation {
+  /**
+   * @param {string}     table
+   * @param {string[][]} newUnique   — new uniqueTogether sets
+   * @param {string[][]} oldUnique   — previous uniqueTogether sets (for down())
+   */
+  constructor(table, newUnique, oldUnique = []) {
+    super();
+    this.type      = 'AlterUniqueTogether';
+    this.table     = table;
+    this.newUnique = newUnique;
+    this.oldUnique = oldUnique;
+  }
+
+  applyState(state) {
+    state.alterUniqueTogether(this.table, this.newUnique);
+  }
+
+  async up(db) {
+    await this._apply(db, this.oldUnique, this.newUnique);
+  }
+
+  async down(db) {
+    await this._apply(db, this.newUnique, this.oldUnique);
+  }
+
+  async _apply(db, remove, add) {
+    await db.schema.table(this.table, (t) => {
+      for (const fields of remove) {
+        const name = `${this.table}_${fields.join('_')}_unique`;
+        try { t.dropUnique(fields, name); } catch { /* already gone */ }
+      }
+      for (const fields of add) {
+        const name = `${this.table}_${fields.join('_')}_unique`;
+        t.unique(fields, { indexName: name });
+      }
+    });
+  }
+
+  toJSON() {
+    return {
+      type:      'AlterUniqueTogether',
+      table:     this.table,
+      newUnique: this.newUnique,
+      oldUnique: this.oldUnique,
+    };
+  }
+}
+
+// ─── RenameIndex ─────────────────────────────────────────────────────────────
+
+class RenameIndex extends BaseOperation {
+  constructor(table, oldName, newName) {
+    super();
+    this.type    = 'RenameIndex';
+    this.table   = table;
+    this.oldName = oldName;
+    this.newName = newName;
+  }
+
+  applyState(state) {
+    state.renameIndex(this.table, this.oldName, this.newName);
+  }
+
+  async up(db) {
+    // knex doesn't have renameIndex — drop and recreate
+    // The index definition is stored on the op for reconstruction
+    await db.schema.table(this.table, (t) => {
+      t.dropIndex([], this.oldName);
+    });
+    await db.schema.table(this.table, (t) => {
+      t.index(this.fields || [], this.newName);
+    });
+  }
+
+  async down(db) {
+    await db.schema.table(this.table, (t) => {
+      t.dropIndex([], this.newName);
+    });
+    await db.schema.table(this.table, (t) => {
+      t.index(this.fields || [], this.oldName);
+    });
+  }
+
+  toJSON() {
+    return { type: 'RenameIndex', table: this.table, oldName: this.oldName, newName: this.newName, fields: this.fields };
+  }
+}
+
+module.exports = { AddIndex, RemoveIndex, AlterUniqueTogether, RenameIndex, indexName, _applyIndex };

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

@@ -28,25 +28,30 @@ class CreateModel extends BaseOperation {
   /**
    * @param {string} table
    * @param {object} fields  — { columnName: normalisedFieldDef }
+   * @param {Array}  [indexes]
+   * @param {Array}  [uniqueTogether]
    */
-  constructor(table, fields) {
+  constructor(table, fields, indexes = [], uniqueTogether = []) {
     super();
-    this.type   = 'CreateModel';
-    this.table  = table;
-    this.fields = fields;
+    this.type          = 'CreateModel';
+    this.table         = table;
+    this.fields        = fields;
+    this.indexes       = indexes;
+    this.uniqueTogether = uniqueTogether;
   }
 
   applyState(state) {
-    state.createModel(this.table, this.fields);
+    state.createModel(this.table, this.fields, this.indexes, this.uniqueTogether);
   }
 
   // Standard up() — inline FKs. Safe when only one CreateModel in a migration.
   async up(db) {
     await db.schema.createTable(this.table, (t) => {
       for (const [name, def] of Object.entries(this.fields)) {
-        applyColumn(t, name, normaliseField(def));
+        applyColumn(t, name, normaliseField(def), this.table);
       }
     });
+    await this._applyIndexes(db);
   }
 
   /**
@@ -56,9 +61,10 @@ class CreateModel extends BaseOperation {
   async upWithoutFKs(db) {
     await db.schema.createTable(this.table, (t) => {
       for (const [name, def] of Object.entries(this.fields)) {
-        applyColumn(t, name, { ...normaliseField(def), references: null });
+        applyColumn(t, name, { ...normaliseField(def), references: null }, this.table);
       }
     });
+    await this._applyIndexes(db);
   }
 
   /**
@@ -76,8 +82,28 @@ class CreateModel extends BaseOperation {
     await db.schema.dropTableIfExists(this.table);
   }
 
+  async _applyIndexes(db) {
+    const { indexName } = require('./indexes');
+    const all = [
+      ...(this.indexes || []),
+    ];
+    const ut = this.uniqueTogether || [];
+    if (!all.length && !ut.length) return;
+    await db.schema.table(this.table, (t) => {
+      for (const idx of all) {
+        const name = idx.name || indexName(this.table, idx.fields, idx.unique);
+        if (idx.unique) t.unique(idx.fields, { indexName: name });
+        else            t.index(idx.fields, name);
+      }
+      for (const fields of ut) {
+        const name = `${this.table}_${fields.join('_')}_unique`;
+        t.unique(fields, { indexName: name });
+      }
+    });
+  }
+
   toJSON() {
-    return { type: 'CreateModel', table: this.table, fields: this.fields };
+    return { type: 'CreateModel', table: this.table, fields: this.fields, indexes: this.indexes, uniqueTogether: this.uniqueTogether };
   }
 }
 
@@ -108,7 +134,7 @@ class DeleteModel extends BaseOperation {
   async down(db) {
     await db.schema.createTable(this.table, (t) => {
       for (const [name, def] of Object.entries(this.fields)) {
-        applyColumn(t, name, normaliseField(def));
+        applyColumn(t, name, normaliseField(def), this.table);
       }
     });
   }