millas 0.2.20 → 0.2.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "millas",
-  "version": "0.2.20",
+  "version": "0.2.23",
   "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/events/EventEmitter.js

@@ -81,7 +81,18 @@ class EventEmitter {
   async _invoke(handler, event) {
     // Listener class (has handle() on prototype)
     if (typeof handler === 'function' && typeof handler.prototype?.handle === 'function') {
-      const inst = new handler();
+      // Resolve static inject dependencies from the container
+      let inst;
+      if (handler.inject && Array.isArray(handler.inject) && handler.inject.length) {
+        const Facade = require('../facades/Facade');
+        const container = Facade._container;
+        const deps = handler.inject.map(key => {
+          try { return container ? container.make(key) : undefined; } catch { return undefined; }
+        });
+        inst = new handler(...deps);
+      } else {
+        inst = new handler();
+      }
       if (handler.queue && this._queue) {
         const Job = require('../queue/Job');
         const q   = this._queue;

package/src/facades/Database.js

@@ -1,43 +1,64 @@
 'use strict';
 
+const Facade = require('./Facade');
+
 /**
- * millas/facades/Database
+ * Database facade — direct access to the knex connection.
+ *
+ * Usage:
+ *   const Database = require('millas/facades/Database');
  *
- * ORM models, field definitions, and query builder.
+ *   // Raw SQL
+ *   const result = await Database.raw('SELECT NOW()');
  *
- *   const { Model, fields } = require('millas/facades/Database');
+ *   // Knex query builder
+ *   const rows = await Database.table('posts').where('published', true).select('*');
  *
- *   class Post extends Model {
- *     static table = 'posts';
- *     static fields = {
- *       id:         fields.id(),
- *       title:      fields.string({ max: 255 }),
- *       author:     fields.ForeignKey('User', { relatedName: 'posts' }),
- *       published:  fields.boolean({ default: false }),
- *       created_at: fields.timestamp(),
- *       updated_at: fields.timestamp(),
- *     };
- *   }
+ *   // Named connection
+ *   const rows = await Database.connection('replica').raw('SELECT 1');
  */
+class Database {
+  static _resolveInstance() {
+    const DatabaseManager = require('../orm/drivers/DatabaseManager');
+    return DatabaseManager.connection();
+  }
+}
+
+// Proxy every static call to the knex connection
+module.exports = new Proxy(Database, {
+  get(target, prop) {
+    // Let real static members through
+    if (prop in target || prop === 'then' || prop === 'catch') {
+      return target[prop];
+    }
+    if (typeof prop === 'symbol') return target[prop];
+
+    // Special case: raw() — normalize result across dialects
+    if (prop === 'raw') {
+      return async (sql, bindings) => {
+        const db = Database._resolveInstance();
+        const result = await db.raw(sql, bindings);
+        // Postgres returns { rows: [...], command, rowCount, ... }
+        // SQLite/MySQL return [rows, fields] or just rows
+        if (result && result.rows) return result.rows;
+        if (Array.isArray(result)) return result[0] ?? result;
+        return result;
+      };
+    }
 
-const {
-  Model,
-  fields,
-  QueryBuilder,
-  DatabaseManager,
-  SchemaBuilder,
-  MigrationRunner,
-  ModelInspector,
-  DatabaseServiceProvider,
-} = require('../core');
+    // Special case: connection(name) returns a named knex instance
+    if (prop === 'connection') {
+      return (name) => {
+        const DatabaseManager = require('../orm/drivers/DatabaseManager');
+        return DatabaseManager.connection(name || null);
+      };
+    }
 
-module.exports = {
-  Model,
-  fields,
-  QueryBuilder,
-  DatabaseManager,
-  SchemaBuilder,
-  MigrationRunner,
-  ModelInspector,
-  DatabaseServiceProvider,
-};
+    // Proxy everything else to the default knex connection
+    return (...args) => {
+      const db = Database._resolveInstance();
+      if (typeof db[prop] !== 'function') return db[prop];
+      return db[prop](...args);
+    };
+  },
+});

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

@@ -101,6 +101,24 @@ const fields = {
         return new FieldDefinition('json', options);
     },
 
+    /**
+     * Array field — stores an ordered list of values.
+     *
+     * On PostgreSQL: uses native ARRAY type (text[], integer[], etc.)
+     * On SQLite/MySQL: falls back to JSON column (same as fields.json())
+     *
+     * @param {string} [of='text']  — item type: 'text' | 'integer' | 'float' | 'boolean'
+     *
+     * @example
+     *   tags:      fields.array()              // text[] on PG, json on SQLite
+     *   scores:    fields.array('integer')     // integer[] on PG
+     *   media_ids: fields.array('integer', { nullable: true, default: [] })
+     */
+    array(of = 'text', options = {}) {
+        if (typeof of === 'object') { options = of; of = 'text'; }
+        return new FieldDefinition('array', { arrayOf: of, nullable: true, default: [], ...options });
+    },
+
     date(options = {}) {
         return new FieldDefinition('date', options);
     },

package/src/orm/migration/MigrationWriter.js

@@ -408,6 +408,12 @@ ${opsCode},
       case 'id':
         return 'fields.id()';
 
+      case 'array': {
+        const of_ = def.arrayOf || 'text';
+        const optsStr = Object.keys(opts).length ? `, ${this._renderOpts(opts)}` : '';
+        return `fields.array('${of_}'${optsStr})`;
+      }
+
       case 'enum': {
         const vals = JSON.stringify(def.enumValues || []);
         const optsStr = Object.keys(opts).length

package/src/orm/migration/ModelInspector.js

@@ -523,6 +523,10 @@ ${this._renderColumn('      ', diff.column, diff.previous, '.alter()')}
                 line = `t.json('${name}')`;
                 break;
 
+            case 'array':
+                line = `t.specificType('${name}', '${field.arrayOf || 'text'}[]')`;
+                break;
+
             case 'date':
                 line = `t.date('${name}')`;
                 break;

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);
@@ -140,49 +93,60 @@ function _buildColumn(t, name, def, opts = {}) {
     case 'json':
       return t.json(name);
 
+    case 'array': {
+      const client = t.client?.config?.client || '';
+      if (client.includes('pg') || client.includes('postgres')) {
+        // Native Postgres ARRAY type
+        const pgTypeMap = {
+          text: 'text', string: 'text',
+          integer: 'integer', int: 'integer',
+          float: 'float', decimal: 'decimal',
+          boolean: 'boolean',
+          uuid: 'uuid',
+        };
+        const pgType = pgTypeMap[def.arrayOf || 'text'] || 'text';
+        return t.specificType(name, `${pgType}[]`);
+      }
+      // SQLite / MySQL — fall back to JSON
+      return t.json(name);
+    }
+
     case 'date':
       return t.date(name);
 
     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 +156,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);
       }
     });
   }