fusion-framework 1.2.0 → 1.2.2

package/index.js

@@ -134,30 +134,43 @@ header.fingerprint = () =>
     : {
         'X-Powered-By': 'Fusion Framework',
         'X-Framework': 'Fusion',
-        'X-Fusion-Version': '1.2.0',
+        ['X-Fusion-Version']: '1.2.2',
       }
 
+function isThenable(value) {
+  return value != null && typeof value.then === 'function'
+}
+
+async function awaitMaybe(value) {
+  // Nested thenables (middleware wrapping async handlers) — same idea as Python
+  // awaiting coroutines before treating the value as an HTTP body.
+  let current = value
+  for (let i = 0; i < 8 && isThenable(current); i++) {
+    current = await current
+  }
+  return current
+}
+
+function mergeResponseHeaders(result, extra) {
+  if (!result || typeof result !== 'object') {
+    return { status: 200, body: result, headers: { ...extra } }
+  }
+  const headers = { ...extra, ...(result.headers || {}) }
+  return { ...result, headers }
+}
+
 function frameworkHeaders() {
   const extra = header.fingerprint()
-  return (request, callNext) => {
-    const result = callNext(request)
-    const apply = (value) => {
-      if (value && typeof value.then === 'function') {
-        return value.then(apply)
-      }
-      if (!value || typeof value !== 'object') {
-        return { status: 200, body: value, headers: { ...extra } }
-      }
-      const headers = { ...extra, ...(value.headers || {}) }
-      return { ...value, headers }
-    }
-    return apply(result)
+  // Async so Promises from callNext are never stuffed into `body` as objects.
+  return async (request, callNext) => {
+    const result = await awaitMaybe(callNext(request))
+    return mergeResponseHeaders(result, extra)
   }
 }
 
 class FusionBaseApi {
   constructor(request) {
-    this.request = request
+    this.request = request && typeof request === 'object' ? request : emptyRequest()
   }
 
   get method() {
@@ -206,7 +219,39 @@ function resolveRoutePath(routePath, ApiClass) {
   return native.resolveRoutePathJs(routePath, ApiClass.name)
 }
 
+function emptyRequest() {
+  return {
+    method: '',
+    path: '',
+    body: '',
+    headers: {},
+    params: {},
+    query: {},
+    state: {},
+  }
+}
+
+/**
+ * N-API threadsafe callbacks may be `(request)` (Fatal) or `(err, request)` (CalleeHandled).
+ * Always return a real request object so middleware never sees `null`.
+ */
+function nativeRequestArg(errOrRequest, maybeRequest) {
+  if (maybeRequest != null && typeof maybeRequest === 'object') {
+    return maybeRequest
+  }
+  if (errOrRequest instanceof Error) {
+    throw errOrRequest
+  }
+  if (errOrRequest != null && typeof errOrRequest === 'object') {
+    return errOrRequest
+  }
+  return emptyRequest()
+}
+
 function ensureState(request) {
+  if (!request || typeof request !== 'object') {
+    return {}
+  }
   if (!request.state || typeof request.state !== 'object') {
     request.state = {}
   }
@@ -219,18 +264,14 @@ function isResponse(value) {
 
 async function runMiddlewareChain(request, middlewares, handler) {
   ensureState(request)
-  let index = 0
 
   async function dispatch(i, req) {
     if (i >= middlewares.length) {
-      return await handler(req)
+      return await awaitMaybe(handler(req))
     }
     const middleware = middlewares[i]
     const callNext = (nextReq) => dispatch(i + 1, nextReq)
-    let result = middleware(req, callNext)
-    if (result && typeof result.then === 'function') {
-      result = await result
-    }
+    const result = await awaitMaybe(middleware(req, callNext))
     if (isResponse(result)) return result
     return result
   }
@@ -595,11 +636,12 @@ class FusionApp {
     for (const { path: routePath, ApiClass, middleware: routeMiddleware = [] } of registry) {
       for (const methodName of HTTP_METHODS) {
         if (!definesMethod(ApiClass, methodName)) continue
-        this.engine.route(methodName.toUpperCase(), routePath, async (request) => {
+        this.engine.route(methodName.toUpperCase(), routePath, (errOrRequest, maybeRequest) => {
+          const request = nativeRequestArg(errOrRequest, maybeRequest)
           const chain = [...activeGlobalMiddleware, ...routeMiddleware]
           const handler = async (req) => {
             try {
-              const instance = new ApiClass(req)
+              const instance = new ApiClass(req || emptyRequest())
               const fn = instance[methodName]
               return await Promise.resolve(fn.call(instance))
             } catch (err) {
@@ -664,12 +706,16 @@ class FusionApp {
         }
       }
 
-      this.engine.route('GET', `${prefix}/openapi.json`, async () => openapi)
-      this.engine.route('GET', prefix, async () => ({
+      const uiEnvelope = () => ({
         status: 200,
         body: swaggerUiHtml(swagger, `${prefix}/openapi.json`),
         headers: { 'content-type': 'text/html' },
-      }))
+      })
+      this.engine.route('GET', `${prefix}/openapi.json`, () => openapi)
+      this.engine.route('GET', prefix, uiEnvelope)
+      if (prefix !== '/') {
+        this.engine.route('GET', `${prefix}/`, uiEnvelope)
+      }
     }
 
     this.mounted = true

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fusion-framework",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "Class-based HTTP framework for Node.js, powered by a shared Rust core via N-API",
   "keywords": [
     "http",