millas 0.2.12-beta → 0.2.12-beta-2

package/src/logger/formatters/PrettyFormatter.js

@@ -1,88 +1,134 @@
 'use strict';
 
-const { LEVEL_NAMES, LEVEL_TAGS, LEVEL_COLOURS, RESET, BOLD, DIM } = require('../levels');
-
-/**
- * PrettyFormatter
- *
- * Colourful, human-readable output. Designed for development.
- * Inspired by Timber (Android) and Laravel's log formatting.
- *
- * Output:
- *   [2026-03-15 12:00:00] I  UserController  User #5 logged in
- *   [2026-03-15 12:00:01] E  Database        Connection refused  { host: 'localhost' }
- *   [2026-03-15 12:00:02] W  Auth            Token expiring soon
- *
- * WTF level also prints the full stack trace.
- */
+const { LEVEL_TAGS, LEVEL_COLOURS, RESET, BOLD } = require('../levels');
+
+const SEP = '  ';
+const TAG_WIDTH = 18;
+
+// Matches /absolute/path/to/file.js or /absolute/path/to/file.js:12:34
+const FILE_PATH_RE = /(\/[^\s)'"]+\.(js|ts|json|mjs|cjs)(?::\d+(?::\d+)?)?)/g;
+// Matches http(s):// URLs
+const URL_RE = /(https?:\/\/[^\s)'"]+)/g;
+
+function linkify(text, dim, useColour) {
+  if (!useColour) return text;
+
+  text = text.replace(FILE_PATH_RE, (match) => {
+    const filePath = match.replace(/(:\d+)+$/, '');
+    const uri = `file://${filePath}`;
+    return `${RESET}\x1b]8;;${uri}\x1b\\${match}\x1b]8;;\x1b\\`;
+  });
+
+  text = text.replace(URL_RE, (match) => {
+    return `${RESET}\x1b]8;;${match}\x1b\\${match}\x1b]8;;\x1b\\`;
+  });
+
+  return text;
+}
+
 class PrettyFormatter {
-  /**
-   * @param {object} options
-   * @param {boolean} [options.timestamp=true]    — show timestamp
-   * @param {boolean} [options.tag=true]          — show tag/component name
-   * @param {boolean} [options.colour=true]       — ANSI colour (disable for pipes/files)
-   * @param {string}  [options.timestampFormat]   — 'iso' | 'short' (default: 'short')
-   */
   constructor(options = {}) {
     this.showTimestamp = options.timestamp !== false;
     this.showTag       = options.tag       !== false;
     this.colour        = options.colour    !== false;
     this.tsFormat      = options.timestampFormat || 'short';
+    this.tagWidth      = options.tagWidth || TAG_WIDTH;
   }
 
   format(entry) {
     const { level, tag, message, context, error } = entry;
 
-    const c    = this.colour ? LEVEL_COLOURS[level] : '';
-    const r    = this.colour ? RESET                : '';
-    const b    = this.colour ? BOLD                 : '';
-    const d    = this.colour ? '\x1b[2m'            : '';
-    const lvl  = LEVEL_TAGS[level] || '?';
+    const c   = this.colour ? (LEVEL_COLOURS[level] || '') : '';
+    const r   = this.colour ? RESET     : '';
+    const b   = this.colour ? BOLD      : '';
+    const d   = this.colour ? '\x1b[2m' : '';
+    const lvl = LEVEL_TAGS[level] || '?';
 
-    const parts = [];
+    // ── 1. Measure plain prefix once ─────────────────────────────────────────
+    const ts = this._timestamp();
+    const plainCols = [];
+    if (this.showTimestamp)    plainCols.push(`[${ts}]`);
+    plainCols.push(lvl);
+    if (this.showTag && tag)   plainCols.push(tag.padEnd(this.tagWidth));
 
-    // Timestamp
-    if (this.showTimestamp) {
-      const ts = this._timestamp();
-      parts.push(`${d}[${ts}]${r}`);
-    }
+    const indentWidth = plainCols.join(SEP).length + SEP.length;
+    const indent      = ' '.repeat(indentWidth);
 
-    // Level tag (single letter, coloured)
-    parts.push(`${c}${b}${lvl}${r}`);
+    // ── 2. Coloured prefix ───────────────────────────────────────────────────
+    const colCols = [];
+    if (this.showTimestamp)    colCols.push(`${d}[${ts}]${r}`);
+    colCols.push(`${c}${b}${lvl}${r}`);
+    if (this.showTag && tag)   colCols.push(`${b}${tag.padEnd(this.tagWidth)}${r}`);
 
-    // Component/tag
-    if (this.showTag && tag) {
-      const tagStr = tag.padEnd(18);
-      parts.push(`${b}${tagStr}${r}`);
-    }
+    const prefix = colCols.join(SEP) + SEP;
 
-    // Message
-    parts.push(`${c}${message}${r}`);
+    // ── 3. Terminal width ────────────────────────────────────────────────────
+    const termWidth = (process.stdout.columns || 120);
+    const msgWidth  = termWidth - indentWidth;
 
-    // Context object
-    if (context !== undefined && context !== null) {
-      const ctx = typeof context === 'object'
-        ? JSON.stringify(context, null, 0)
-        : String(context);
-      parts.push(`${d}${ctx}${r}`);
-    }
+    // ── 4. Collect all logical lines ─────────────────────────────────────────
+    const logicalLines = [];
+
+    for (const l of String(message).split('\n')) logicalLines.push({ text: l, dim: false });
 
-    let output = parts.join('  ');
+    if (context != null) {
+      const ctx = typeof context === 'object' ? JSON.stringify(context) : String(context);
+      logicalLines.push({ text: ctx, dim: true });
+    }
 
-    // Error stack
     if (error instanceof Error) {
-      output += `\n${d}${error.stack || error.message}${r}`;
+      for (const l of (error.stack || error.message).split('\n'))
+        logicalLines.push({ text: l, dim: true });
+    }
+
+    // ── 5. Hard-wrap (skip stack frames so paths stay intact) ────────────────
+    const wrappedLines = [];
+
+    for (const { text, dim } of logicalLines) {
+      const isStackFrame = dim && /^\s*at /.test(text);
+
+      if (isStackFrame || text.length <= msgWidth) {
+        wrappedLines.push({ text, dim });
+        continue;
+      }
+
+      const words = text.split(' ');
+      let chunk = '';
+      for (const word of words) {
+        if (chunk.length === 0) {
+          if (word.length > msgWidth) {
+            for (let i = 0; i < word.length; i += msgWidth)
+              wrappedLines.push({ text: word.slice(i, i + msgWidth), dim });
+          } else {
+            chunk = word;
+          }
+        } else if (chunk.length + 1 + word.length <= msgWidth) {
+          chunk += ' ' + word;
+        } else {
+          wrappedLines.push({ text: chunk, dim });
+          chunk = word;
+        }
+      }
+      if (chunk.length) wrappedLines.push({ text: chunk, dim });
     }
 
-    // WTF: print big warning banner
+    // ── 6. Render + linkify ───────────────────────────────────────────────────
+    const rendered = wrappedLines.map((line, i) => {
+      const col  = line.dim ? d : c;
+      const text = linkify(line.text, line.dim, this.colour);
+      if (i === 0) return `${prefix}${col}${text}${r}`;
+      return `${indent}${col}${text}${r}`;
+    }).join('\n');
+
+    // ── 7. WTF banner ─────────────────────────────────────────────────────────
     if (level === 5) {
-      const banner = this.colour
+      const bar = this.colour
         ? `\x1b[35m\x1b[1m${'━'.repeat(60)}\x1b[0m`
         : '━'.repeat(60);
-      output = `${banner}\n${output}\n${banner}`;
+      return `${bar}\n${rendered}\n${bar}`;
     }
 
-    return output;
+    return rendered;
   }
 
   _timestamp() {
@@ -92,4 +138,4 @@ class PrettyFormatter {
   }
 }
 
-module.exports = PrettyFormatter;
+module.exports = PrettyFormatter;

package/src/logger/internal.js

@@ -64,12 +64,12 @@ const MillasLog = new Logger();
 // from the framework itself unless you opt in to lower levels.
 MillasLog.configure({
   defaultTag: 'Millas',
-  minLevel:   LEVELS.WARN,
+  minLevel:   LEVELS.VERBOSE,
   channel:    new ConsoleChannel({
     formatter: new PrettyFormatter({
       colour: process.stdout.isTTY !== false,
     }),
-    minLevel: LEVELS.WARN,
+    minLevel: LEVELS.VERBOSE,
   }),
 });
 

package/src/logger/patchConsole.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { LEVELS } = require('./levels');
+const {LEVELS} = require('./levels');
 
 /**
  * patchConsole(Log, defaultTag)
@@ -25,44 +25,54 @@ const { LEVELS } = require('./levels');
  *   console.dir   → Log.d  (DEBUG)
  */
 function patchConsole(Log, defaultTag = 'App') {
-  // Save originals — restore() puts these back
-  const originals = {
-    log:   console.log.bind(console),
-    info:  console.info.bind(console),
-    warn:  console.warn.bind(console),
-    error: console.error.bind(console),
-    debug: console.debug.bind(console),
-    trace: console.trace.bind(console),
-    dir:   console.dir.bind(console),
-  };
-
-  // Build a dispatcher for a given level
-  function make(level) {
-    return function (...args) {
-      const { message, context, error } = parse(args);
-      Log._emit({
-        level,
-        tag:       defaultTag,
-        message:   message || '',
-        context,
-        error,
+
+    // Save originals — restore() puts these back
+    const originals = {
+        log: console.log.bind(console),
+        info: console.info.bind(console),
+        warn: console.warn.bind(console),
+        error: console.error.bind(console),
+        debug: console.debug.bind(console),
+        trace: console.trace.bind(console),
+        dir: console.dir.bind(console),
+    };
+
+    // Build a dispatcher for a given level
+    function make(level) {
+        return function (...args) {
+            const {message, context, error} = parse(args);
+            Log._emit({
+                level,
+                tag: defaultTag,
+                message: message || '',
+                context,
+                error,
+                timestamp: new Date().toISOString(),
+                pid: process.pid,
+            });
+            return true
+        };
+    }
+
+    console.log = make(LEVELS.INFO);
+    console.info = make(LEVELS.INFO);
+    console.warn = make(LEVELS.WARN);
+    console.error = make(LEVELS.ERROR);
+    console.debug = make(LEVELS.DEBUG);
+    console.trace = make(LEVELS.VERBOSE);
+    console.dir = (obj) => Log._emit({
+        level: LEVELS.DEBUG,
+        tag: defaultTag,
+        message: '',
+        context: obj,
+        error: undefined,
         timestamp: new Date().toISOString(),
-        pid:       process.pid,
-      });
+        pid: process.pid
+    });
+
+    return function restore() {
+        Object.assign(console, originals);
     };
-  }
-
-  console.log   = make(LEVELS.INFO);
-  console.info  = make(LEVELS.INFO);
-  console.warn  = make(LEVELS.WARN);
-  console.error = make(LEVELS.ERROR);
-  console.debug = make(LEVELS.DEBUG);
-  console.trace = make(LEVELS.VERBOSE);
-  console.dir   = (obj) => Log._emit({ level: LEVELS.DEBUG, tag: defaultTag, message: '', context: obj, error: undefined, timestamp: new Date().toISOString(), pid: process.pid });
-
-  return function restore() {
-    Object.assign(console, originals);
-  };
 }
 
 // ── Argument parser ───────────────────────────────────────────────────────────
@@ -78,58 +88,58 @@ function patchConsole(Log, defaultTag = 'App') {
 //   console.log('a', 'b', 'c')     → message: 'a b c'
 
 function parse(args) {
-  if (args.length === 0) {
-    return { message: '', context: undefined, error: undefined };
-  }
-
-  if (args.length === 1) {
-    const a = args[0];
-    if (a instanceof Error)                      return { message: a.message,    context: undefined, error: a };
-    if (typeof a === 'object' && a !== null)     return { message: '',           context: a,         error: undefined };
-    return { message: String(a), context: undefined, error: undefined };
-  }
-
-  const [first, ...rest] = args;
-
-  // First arg is an Error
-  if (first instanceof Error) {
-    return { message: first.message, context: rest.length ? rest : undefined, error: first };
-  }
-
-  // First arg is a string message
-  if (typeof first === 'string') {
-    // Single extra arg
-    if (rest.length === 1) {
-      const r = rest[0];
-      if (r instanceof Error)                    return { message: first, context: undefined, error: r };
-      if (typeof r === 'object' && r !== null)   return { message: first, context: r,         error: undefined };
-      // Scalar extra: append to message (console.log('count:', 42))
-      return { message: first + ' ' + String(r), context: undefined, error: undefined };
+    if (args.length === 0) {
+        return {message: '', context: undefined, error: undefined};
     }
 
-    // Multiple extra args — find a trailing Error, collect the rest as context
-    const lastArg = rest[rest.length - 1];
-    if (lastArg instanceof Error) {
-      const ctx = rest.slice(0, -1);
-      return { message: first, context: ctx.length ? ctx : undefined, error: lastArg };
+    if (args.length === 1) {
+        const a = args[0];
+        if (a instanceof Error) return {message: a.message, context: undefined, error: a};
+        if (typeof a === 'object' && a !== null) return {message: '', context: a, error: undefined};
+        return {message: String(a), context: undefined, error: undefined};
     }
 
-    // All strings/scalars — join into message
-    if (rest.every(r => typeof r !== 'object' || r === null)) {
-      return { message: [first, ...rest].map(String).join(' '), context: undefined, error: undefined };
+    const [first, ...rest] = args;
+
+    // First arg is an Error
+    if (first instanceof Error) {
+        return {message: first.message, context: rest.length ? rest : undefined, error: first};
     }
 
-    // Mixed — put extras in context
-    return { message: first, context: rest, error: undefined };
-  }
+    // First arg is a string message
+    if (typeof first === 'string') {
+        // Single extra arg
+        if (rest.length === 1) {
+            const r = rest[0];
+            if (r instanceof Error) return {message: first, context: undefined, error: r};
+            if (typeof r === 'object' && r !== null) return {message: first, context: r, error: undefined};
+            // Scalar extra: append to message (console.log('count:', 42))
+            return {message: first + ' ' + String(r), context: undefined, error: undefined};
+        }
+
+        // Multiple extra args — find a trailing Error, collect the rest as context
+        const lastArg = rest[rest.length - 1];
+        if (lastArg instanceof Error) {
+            const ctx = rest.slice(0, -1);
+            return {message: first, context: ctx.length ? ctx : undefined, error: lastArg};
+        }
+
+        // All strings/scalars — join into message
+        if (rest.every(r => typeof r !== 'object' || r === null)) {
+            return {message: [first, ...rest].map(String).join(' '), context: undefined, error: undefined};
+        }
+
+        // Mixed — put extras in context
+        return {message: first, context: rest, error: undefined};
+    }
 
-  // First arg is an object
-  if (typeof first === 'object' && first !== null) {
-    return { message: '', context: first, error: undefined };
-  }
+    // First arg is an object
+    if (typeof first === 'object' && first !== null) {
+        return {message: '', context: first, error: undefined};
+    }
 
-  // Fallback — join everything as a string
-  return { message: args.map(String).join(' '), context: undefined, error: undefined };
+    // Fallback — join everything as a string
+    return {message: args.map(String).join(' '), context: undefined, error: undefined};
 }
 
 module.exports = patchConsole;

package/src/middleware/MiddlewareRegistry.js

@@ -1,54 +1,68 @@
 'use strict';
 
-const MillasRequest      = require('../http/MillasRequest');
-const MillasResponse     = require('../http/MillasResponse');
-const ResponseDispatcher = require('../http/ResponseDispatcher');
-const RequestContext     = require('../http/RequestContext');
-
 /**
  * MiddlewareRegistry
  *
- * Maps string aliases → middleware handler classes or functions.
- * Resolves them into Express-compatible functions that wrap with MillasRequest.
+ * Maps string aliases → Millas middleware classes or instances.
+ * Resolution produces adapter-native handler functions via the adapter,
+ * so this class has zero knowledge of Express (or any HTTP engine).
+ *
+ * The adapter is injected at resolution time (not construction time)
+ * so the registry can be built before the adapter exists.
  */
 class MiddlewareRegistry {
-  constructor(container = null) {
-    this._map       = {};
-    this._container = container;
+  constructor() {
+    this._map = {};
   }
 
+  /**
+   * Register a middleware alias.
+   *
+   *   registry.register('auth',     AuthMiddleware)
+   *   registry.register('throttle', new ThrottleMiddleware({ max: 60 }))
+   */
   register(alias, handler) {
     this._map[alias] = handler;
     return this;
   }
 
   /**
-   * Resolve a middleware alias or function into an Express-compatible handler.
-   *
-   * Millas middleware (class with handle(req, next)):
-   *   - Receives MillasRequest
-   *   - Returns MillasResponse or calls next()
-   *   - Kernel dispatches the MillasResponse if returned
+   * Resolve a middleware alias or class/instance into an adapter-native handler.
    *
-   * Raw Express functions (legacy/escape hatch):
-   *   - Passed through as-is
+   * @param {string|Function|object} aliasOrFn
+   * @param {import('../http/adapters/HttpAdapter')} adapter
+   * @param {object|null} container
+   * @returns {Function}  adapter-native handler
    */
-  resolve(aliasOrFn) {
-    // Raw function — check if it's a Millas middleware class or legacy Express fn
-    if (typeof aliasOrFn === 'function') {
-      return this._wrapHandler(aliasOrFn);
-    }
+  resolve(aliasOrFn, adapter, container = null) {
+    const Handler = typeof aliasOrFn === 'string'
+      ? this._map[aliasOrFn]
+      : aliasOrFn;
 
-    const Handler = this._map[aliasOrFn];
     if (!Handler) {
       throw new Error(`Middleware "${aliasOrFn}" is not registered.`);
     }
 
-    return this._wrapHandler(Handler);
+    return this._wrap(Handler, adapter, container);
+  }
+
+  /**
+   * Resolve all aliases in a list.
+   */
+  resolveAll(list = [], adapter, container = null) {
+    return list.map(m => this.resolve(m, adapter, container));
   }
 
-  resolveAll(list = []) {
-    return list.map(m => this.resolve(m));
+  /**
+   * Return a no-op passthrough handler for the given adapter.
+   * Used when a middleware alias is missing but should not crash the app.
+   */
+  resolvePassthrough(adapter) {
+    // Adapter-agnostic: return a function matching the native signature
+    // by asking the adapter to wrap a no-op middleware instance.
+    return adapter.wrapMiddleware({
+      handle: (_ctx, next) => next(),
+    }, null);
   }
 
   has(alias) {
@@ -56,71 +70,37 @@ class MiddlewareRegistry {
   }
 
   all() {
-    return { ...this._map }; }
+    return { ...this._map };
+  }
 
-  // ─── Internal ──────────────────────────────────────────────────────────────
+  // ── Internal ────────────────────────────────────────────────────────────────
 
-  _wrapHandler(Handler) {
-    // Pre-instantiated Millas middleware object: { handle(req, next) }
-    if (typeof Handler === 'object' && Handler !== null &&
-        typeof Handler.handle === 'function') {
-      return this._buildMillasWrapper(Handler);
+  _wrap(Handler, adapter, container) {
+    // Pre-instantiated Millas middleware object with handle()
+    if (
+      typeof Handler === 'object' &&
+      Handler !== null &&
+      typeof Handler.handle === 'function'
+    ) {
+      return adapter.wrapMiddleware(Handler, container);
     }
 
-    // Millas middleware class (has handle on prototype, not Express signature)
-    if (typeof Handler === 'function' &&
-        Handler.prototype &&
-        typeof Handler.prototype.handle === 'function') {
-      const instance = new Handler();
-      return this._buildMillasWrapper(instance);
+    // Millas middleware class (handle on prototype)
+    if (
+      typeof Handler === 'function' &&
+      Handler.prototype &&
+      typeof Handler.prototype.handle === 'function'
+    ) {
+      return adapter.wrapMiddleware(new Handler(), container);
     }
 
-    // Legacy raw Express function: (req, res, next) => void
-    // Pass through unchanged — developers using old style still work
+    // Raw adapter-native function — pass through as-is (escape hatch)
     if (typeof Handler === 'function') {
       return Handler;
     }
 
-    throw new Error(`Middleware must be a function or a class with handle().`);
-  }
-
-  /**
-   * Build an Express-compatible function from a Millas middleware instance.
-   *
-   * The middleware's handle(req, next) is called with a MillasRequest.
-   * If it returns a MillasResponse, that response is dispatched immediately.
-   * If it calls next(), Express continues down the chain.
-   */
-  _buildMillasWrapper(instance) {
-    const container = this._container;
-
-    return (expressReq, expressRes, expressNext) => {
-      const millaReq = new MillasRequest(expressReq);
-      const ctx      = new RequestContext(millaReq, container);
-
-      const next = () => {
-        expressNext();
-        return undefined;
-      };
-
-      new Promise((resolve, reject) => {
-        try {
-          resolve(instance.handle(ctx, next));
-        } catch (err) {
-          reject(err);
-        }
-      })
-      .then(value => {
-        if (value !== undefined && value !== null && !expressRes.headersSent) {
-          const response = MillasResponse.isResponse(value)
-            ? value
-            : ResponseDispatcher.autoWrap(value);
-          ResponseDispatcher.dispatch(response, expressRes);
-        }
-      })
-      .catch(expressNext);
-    };
+    throw new Error('Middleware must be a function or a class with handle().');
   }
 }
 
-module.exports = MiddlewareRegistry;
+module.exports = MiddlewareRegistry;

package/src/migrations/system/0001_users.js

@@ -0,0 +1,21 @@
+'use strict';
+
+/**
+ * System migration: 0001_users
+ *
+ * Previously created the users table directly.
+ *
+ * As of Millas 0.3+, the users table is owned by the APP — not the framework.
+ * AuthUser is now fully abstract (no table). The app defines its own User model
+ * that extends AuthUser and owns whatever table it wants (typically 'users').
+ *
+ * This migration is kept as a no-op so existing projects that depend on
+ * ['system', '0001_users'] don't break. It creates nothing.
+ *
+ * Equivalent to Django's pattern: AbstractUser has no table; your custom
+ * User model creates its own table via app migrations.
+ */
+module.exports = {
+  dependencies: [],
+  operations:   [],
+};

package/src/migrations/system/0002_admin_log.js

@@ -0,0 +1,25 @@
+'use strict';
+
+const { CreateModel } = require('../../orm/migration/operations');
+
+/**
+ * System migration: millas_admin_log
+ * Equivalent to Django's django_admin_log.
+ */
+module.exports = {
+  dependencies: [['system', '0001_users']],
+
+  operations: [
+    new CreateModel('millas_admin_log', {
+      id:         { type: 'id',        unsigned: true,  nullable: false, unique: false, default: null, max: null, enumValues: null, references: null, precision: null, scale: null },
+      user_id:    { type: 'integer',   unsigned: true,  nullable: true,  unique: false, default: null, max: null, enumValues: null, references: { table: 'users', column: 'id', onDelete: 'SET NULL' }, precision: null, scale: null },
+      user_email: { type: 'string',    max: 255,        nullable: true,  unique: false, default: null, unsigned: false, enumValues: null, references: null, precision: null, scale: null },
+      resource:   { type: 'string',    max: 100,        nullable: false, unique: false, default: null, unsigned: false, enumValues: null, references: null, precision: null, scale: null },
+      record_id:  { type: 'string',    max: 100,        nullable: true,  unique: false, default: null, unsigned: false, enumValues: null, references: null, precision: null, scale: null },
+      action:     { type: 'enum',      enumValues: ['create','update','delete'], nullable: false, unique: false, default: null, max: null, unsigned: false, references: null, precision: null, scale: null },
+      label:      { type: 'string',    max: 255,        nullable: true,  unique: false, default: null, unsigned: false, enumValues: null, references: null, precision: null, scale: null },
+      change_msg: { type: 'text',      nullable: true,  unique: false, default: null, max: null, unsigned: false, enumValues: null, references: null, precision: null, scale: null },
+      created_at: { type: 'timestamp', nullable: true,  unique: false, default: null, max: null, unsigned: false, enumValues: null, references: null, precision: null, scale: null },
+    }),
+  ],
+};