millas 0.2.21 → 0.2.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "millas",
-  "version": "0.2.21",
+  "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/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/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

@@ -93,6 +93,24 @@ 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);
 

package/src/orm/model/Model.js

@@ -957,7 +957,8 @@ class Model {
       case 'bigInteger': return typeof val === 'bigint' ? val : parseInt(val, 10);
       case 'float':
       case 'decimal':    return typeof val === 'number' ? val : parseFloat(val);
-      case 'json':       return typeof val === 'string' ? JSON.parse(val) : val;
+      case 'json':
+      case 'array':      return typeof val === 'string' ? JSON.parse(val) : (Array.isArray(val) ? val : (val ?? []));
       case 'date':
       case 'timestamp':  {
         if (val instanceof Date) return isNaN(val.getTime()) ? null : val;
@@ -981,7 +982,7 @@ class Model {
 
   static _serializeValue(val, type) {
     if (val == null) return val;
-    if (type === 'json') return typeof val === 'string' ? val : JSON.stringify(val);
+    if (type === 'json' || type === 'array') return typeof val === 'string' ? val : JSON.stringify(val);
     if (type === 'boolean') return val ? 1 : 0;
     if ((type === 'date' || type === 'timestamp') && val instanceof Date) return val.toISOString();
     return val;

package/src/orm/query/QueryBuilder.js

@@ -253,6 +253,27 @@ class QueryBuilder {
     return this;
   }
 
+  join(table, col1, col2, col3) {
+    this._query = col3
+      ? this._query.join(table, col1, col2, col3)
+      : this._query.join(table, col1, col2);
+    return this;
+  }
+
+  leftJoin(table, col1, col2, col3) {
+    this._query = col3
+      ? this._query.leftJoin(table, col1, col2, col3)
+      : this._query.leftJoin(table, col1, col2);
+    return this;
+  }
+
+  rightJoin(table, col1, col2, col3) {
+    this._query = col3
+      ? this._query.rightJoin(table, col1, col2, col3)
+      : this._query.rightJoin(table, col1, col2);
+    return this;
+  }
+
   having(column, operatorOrValue, value) {
     if (value !== undefined) {
       this._query = this._query.having(column, operatorOrValue, value);
@@ -561,6 +582,38 @@ class QueryBuilder {
         continue;
       }
 
+      // -- Nested dot notation: 'documents.document_images'
+      // Matches Django's prefetch_related('documents__document_images')
+      if (name.includes('.')) {
+        const [parentRel, ...rest] = name.split('.');
+        const nestedName = rest.join('.');
+        const parentRelDef = relations[parentRel];
+        if (!parentRelDef) {
+          MillasLog.w('ORM', `Relation "${parentRel}" not defined on ${this._model.name} -- skipping nested eager load`);
+          continue;
+        }
+        const alreadyLoaded = instances[0]?.[parentRel] !== undefined &&
+          typeof instances[0]?.[parentRel] !== 'function';
+        if (!alreadyLoaded) {
+          await parentRelDef.eagerLoad(instances, parentRel, null);
+        }
+        const parentInstances = instances.flatMap(i => {
+          const val = i[parentRel];
+          if (!val) return [];
+          return Array.isArray(val) ? val : [val];
+        });
+        if (parentInstances.length) {
+          const RelatedModel = parentRelDef._related;
+          if (RelatedModel) {
+            const QB = require('./QueryBuilder');
+            const subQb = new QB(RelatedModel._db(), RelatedModel);
+            subQb._withs = [{ name: nestedName, constraint: null }];
+            await subQb._eagerLoad(parentInstances);
+          }
+        }
+        continue;
+      }
+
       // ── Normal eager load ─────────────────────────────────────────────────
       const rel = relations[name];
       if (!rel) {