millas 0.2.20 → 0.2.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "millas",
-  "version": "0.2.20",
+  "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/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/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,22 +59,11 @@ 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':
@@ -119,14 +76,10 @@ function _buildColumn(t, name, def, opts = {}) {
       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);
@@ -146,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
@@ -192,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/models.js

@@ -48,7 +48,7 @@ class CreateModel extends BaseOperation {
   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);
@@ -61,7 +61,7 @@ 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);
@@ -134,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);
       }
     });
   }