millas 0.2.12-beta → 0.2.12-beta-1

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;