runtimes/js: Added middleware functionality

runtimes/core/src/api/endpoint.rs

@@ -108,6 +108,7 @@ pub type HandlerResponse = APIResult<HandlerResponseInner>;
 pub struct HandlerResponseInner {
     pub payload: JSONPayload,
     pub extra_headers: Option<HeaderMap>,
+    pub status: Option<u16>,
 }
 
 /// A trait for handlers that accept a request and return a response.
@@ -601,20 +602,18 @@ impl EndpointHandler {
                 Some(fields)
             });
 
-            let (status_code, mut encoded_resp, resp_payload, extra_headers, error) = match resp {
-                ResponseData::Raw(resp) => (resp.status().as_u16(), resp, None, None, None),
+            let (mut encoded_resp, resp_payload, extra_headers, error) = match resp {
+                ResponseData::Raw(resp) => (resp, None, None, None),
                 ResponseData::Typed(Ok(response)) => (
-                    200,
                     self.endpoint
                         .response
-                        .encode(&response.payload)
+                        .encode(&response.payload, response.status.unwrap_or(200))
                         .unwrap_or_else(|err| err.to_response(internal_caller)),
                     Some(response.payload),
                     response.extra_headers,
                     None,
                 ),
                 ResponseData::Typed(Err(err)) => (
-                    err.code.status_code().as_u16(),
                     err.as_ref().to_response(internal_caller),
                     None,
                     None,
@@ -627,7 +626,7 @@ impl EndpointHandler {
                     request: request.clone(),
                     duration,
                     data: model::ResponseData::RPC(model::RPCResponseData {
-                        status_code,
+                        status_code: encoded_resp.status().as_u16(),
                         resp_payload,
                         error,
                         resp_headers: encoded_resp.headers().clone(),

runtimes/core/src/api/schema/mod.rs

@@ -114,8 +114,9 @@ impl Response {
     pub fn encode(
         &self,
         payload: &JSONPayload,
+        status: u16,
     ) -> APIResult<axum::http::Response<axum::body::Body>> {
-        let mut bld = axum::http::Response::builder().status(200);
+        let mut bld = axum::http::Response::builder().status(status);
 
         if let Some(hdr) = &self.header {
             bld = hdr.to_response(payload, bld)?

runtimes/js/encore.dev/api/mod.ts

@@ -300,6 +300,7 @@ export class MiddlewareRequest {
   private _stream?: IterableStream | IterableSocket | Sink;
   private _rawReq?: RawRequest;
   private _rawResp?: RawResponse;
+  private _data?: Record<string, any>;
 
   constructor(
     stream?: IterableStream | IterableSocket | Sink,
@@ -339,6 +340,17 @@ export class MiddlewareRequest {
   public get rawResponse(): RawResponse | undefined {
     return this._rawResp;
   }
+
+  /**
+   * data can be used to pass data from middlewares to the handler.
+   * The data will be available via `currentRequest()`
+   */
+  public get data(): Record<string, any> {
+    if (this._data === undefined) {
+      this._data = {};
+    }
+    return this._data;
+  }
 }
 
 export class ResponseHeader {
@@ -379,6 +391,7 @@ export class HandlerResponse {
   payload: any;
 
   private _headers?: ResponseHeader;
+  private _status?: number;
 
   constructor(payload: any) {
     this.payload = payload;
@@ -397,13 +410,21 @@ export class HandlerResponse {
     return this._headers;
   }
 
+  /**
+   * Override the http status code for successful requests for typed endpoints.
+   */
+  public set status(s: number) {
+    this._status = s;
+  }
+
   /**
    * __internalToResponse converts a response to the internal representation
    */
   __internalToResponse(): InternalHandlerResponse {
     return {
       payload: this.payload,
-      extraHeaders: this._headers?.headers
+      extraHeaders: this._headers?.headers,
+      status: this._status
     };
   }
 }

runtimes/js/encore.dev/internal/appinit/mod.ts

@@ -39,7 +39,7 @@ export async function run(entrypoint: string) {
   }
 
   // This is a worker thread. The runtime is already initialized, so block forever.
-  await new Promise(() => { });
+  await new Promise(() => {});
 }
 
 interface EndpointOptions {
@@ -52,10 +52,12 @@ interface EndpointOptions {
 export interface InternalHandlerResponse {
   payload: any;
   extraHeaders?: Record<string, string | string[]>;
+  status?: number;
 }
 
 // recursively calls all middlewares
 async function invokeMiddlewareChain(
+  curReq: runtime.Request,
   req: MiddlewareRequest,
   chain: Middleware[],
   handler: () => Promise<any>
@@ -68,6 +70,10 @@ async function invokeMiddlewareChain(
 
     // no more middlewares, execute the handler
     if (currentMiddleware === undefined) {
+      const mwData = req.data;
+      if (mwData !== undefined) {
+        (curReq as any).middlewareData = mwData;
+      }
       return new HandlerResponse(await handler());
     }
 
@@ -172,7 +178,7 @@ function transformHandler(h: Handler): runtime.ApiRoute {
           undefined,
           undefined
         );
-        return invokeMiddlewareChain(mwRequest, middlewares, handler);
+        return invokeMiddlewareChain(req, mwRequest, middlewares, handler);
       }
     };
   }
@@ -199,7 +205,7 @@ function transformHandler(h: Handler): runtime.ApiRoute {
         };
 
         const mwRequest = new MiddlewareRequest(undefined, rawReq, rawResp);
-        return invokeMiddlewareChain(mwRequest, middlewares, handler);
+        return invokeMiddlewareChain(req, mwRequest, middlewares, handler);
       }
     };
   }
@@ -224,7 +230,7 @@ function transformHandler(h: Handler): runtime.ApiRoute {
       };
 
       const mwRequest = new MiddlewareRequest(undefined, undefined, undefined);
-      return invokeMiddlewareChain(mwRequest, middlewares, handler);
+      return invokeMiddlewareChain(req, mwRequest, middlewares, handler);
     }
   };
 }

runtimes/js/encore.dev/internal/reqtrack/mod.ts

@@ -10,7 +10,7 @@ createHook({
     if (cr) {
       resource[sym] = cr[sym];
     }
-  },
+  }
 }).enable();
 
 export function setCurrentRequest(req: runtime.Request) {

runtimes/js/encore.dev/req_meta.ts

@@ -73,6 +73,11 @@ export interface APICallMeta {
    * request data.
    */
   parsedPayload?: Record<string, any>;
+
+  /**
+   * Contains values set in middlewares via `MiddlewareRequest.data`.
+   */
+  middlewareData?: Record<string, any>;
 }
 
 /** Describes a Pub/Sub message being processed. */
@@ -173,7 +178,8 @@ export function currentRequest(): RequestMeta | undefined {
       pathAndQuery: meta.apiCall.pathAndQuery,
       pathParams: meta.apiCall.pathParams ?? {},
       parsedPayload: meta.apiCall.parsedPayload,
-      headers: meta.apiCall.headers
+      headers: meta.apiCall.headers,
+      middlewareData: (req as any).middlewareData
     };
     return { ...base, ...api };
   } else if (meta.pubsubMessage) {

runtimes/js/src/api.rs

@@ -95,6 +95,7 @@ impl PromiseHandler for APIPromiseHandler {
             return Ok(HandlerResponseInner {
                 payload: None,
                 extra_headers: None,
+                status: None,
             });
         };
 
@@ -110,9 +111,33 @@ impl PromiseHandler for APIPromiseHandler {
             .get_named_property::<napi::JsUnknown>("extraHeaders")
             .map_err(api::Error::internal)?;
 
+        let status = obj
+            .get_named_property::<napi::JsUnknown>("status")
+            .map_err(api::Error::internal)?;
+
+        let status = if status
+            .get_type()
+            .is_ok_and(|t| matches!(t, napi::ValueType::Number))
+        {
+            Some(
+                status
+                    .coerce_to_number()
+                    .map_err(api::Error::internal)
+                    .and_then(|s| s.get_uint32().map_err(api::Error::internal))
+                    .and_then(|s| {
+                        u16::try_from(s).map_err(|e| {
+                            api::Error::invalid_argument("invalid http status code", e)
+                        })
+                    })?,
+            )
+        } else {
+            None
+        };
+
         match parse_pvalues(payload) {
             Ok(val) => Ok(HandlerResponseInner {
                 payload: val,
+                status,
                 extra_headers: parse_header_map(extra_headers)
                     .map_err(|e| api::Error::invalid_argument("unable to parse extraHeaders", e))?,
             }),

runtimes/js/src/gateway.rs

@@ -120,12 +120,14 @@ impl PromiseHandler for AuthPromiseHandler {
             return Ok(HandlerResponseInner {
                 payload: None,
                 extra_headers: None,
+                status: None,
             });
         };
         match parse_pvalues(val) {
             Ok(val) => Ok(HandlerResponseInner {
                 payload: val,
                 extra_headers: None,
+                status: None,
             }),
             Err(err) => self.error(env, err),
         }