alien-middleware 0.10.0 → 0.10.2

package/dist/{index-B3m3gxNA.d.ts → index-CqtSRV4s.d.ts}

@@ -113,9 +113,11 @@ type RequestContext<TEnv extends object = any, TProperties extends object = neve
  *
  * When type `T` is `never`, a default context is returned.
  */
-type MiddlewareContext<T extends MiddlewareChain> = [T] extends [never] ? RequestContext<{}, never, unknown> : RequestContext<Env<T>, Properties<T>, Platform<T>>;
-type IsolatedContext<T extends MiddlewareChain> = RequestContext<InputProperties<T>, InputEnv<T>, Platform<T>>;
-type RequestMiddleware<T extends MiddlewareChain = MiddlewareChain> = (context: RequestContext<InputProperties<T>, InputEnv<T>, Platform<T>>) => Awaitable<Response | RequestPlugin | void>;
+type MiddlewareContext<T extends MiddlewareChain | Middleware[]> = [
+    T
+] extends [never] ? RequestContext<{}, never, unknown> : T extends MiddlewareChain ? RequestContext<Env<T>, Properties<T>, Platform<T>> : T extends Middleware[] ? MiddlewareContext<ApplyMiddlewares<T>> : never;
+type IsolatedContext<T extends MiddlewareChain> = RequestContext<InputEnv<T>, InputProperties<T>, Platform<T>>;
+type RequestMiddleware<T extends MiddlewareChain = MiddlewareChain> = (context: RequestContext<InputEnv<T>, InputProperties<T>, Platform<T>>) => Awaitable<Response | RequestPlugin | void>;
 type ResponseCallback = (response: Response) => Awaitable<Response | void>;
 interface RequestHandler<T extends MiddlewareTypes = any> extends HattipHandler<T['platform']>, MiddlewareChain<T> {
 }

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-export { A as ApplyMiddleware, e as ApplyMiddlewares, g as EnvAccessor, h as ExtractMiddleware, i as Middleware, a as MiddlewareChain, M as MiddlewareContext, j as RequestContext, k as RequestHandler, l as RequestMiddleware, m as RequestPlugin, n as ResponseCallback, d as chain, f as filterPlatform } from './index-B3m3gxNA.js';
+export { A as ApplyMiddleware, e as ApplyMiddlewares, g as EnvAccessor, h as ExtractMiddleware, i as Middleware, a as MiddlewareChain, M as MiddlewareContext, j as RequestContext, k as RequestHandler, l as RequestMiddleware, m as RequestPlugin, n as ResponseCallback, d as chain, f as filterPlatform } from './index-CqtSRV4s.js';
 import '@hattip/core';
 import 'pathic';

package/dist/router.d.ts

@@ -1,5 +1,5 @@
-import { R as Router, M as MiddlewareContext, a as MiddlewareChain, E as EmptyMiddlewareChain } from './index-B3m3gxNA.js';
-export { b as RouteContext, c as RouteHandler } from './index-B3m3gxNA.js';
+import { R as Router, M as MiddlewareContext, a as MiddlewareChain, E as EmptyMiddlewareChain } from './index-CqtSRV4s.js';
+export { b as RouteContext, c as RouteHandler } from './index-CqtSRV4s.js';
 import '@hattip/core';
 import 'pathic';
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "alien-middleware",
   "type": "module",
-  "version": "0.10.0",
+  "version": "0.10.2",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",

package/readme.md

@@ -154,6 +154,14 @@ Request middleware runs sequentially before a `Response` is generated.
   const app = chain().use(addApiKey).use(useApiKey)
   ```
 
+- **Setting Response Headers:** Call the `context.setHeader()` method to set a response header.
+
+  ```typescript
+  const app = chain().use(context => {
+    context.setHeader('X-Powered-By', 'alien-middleware')
+  })
+  ```
+
 > [!NOTE]
 > If you're wondering why you need to return an object to define properties
 > (rather than simply assigning to the context object), it's because TypeScript
@@ -203,6 +211,25 @@ console.log(response.headers.get('X-Powered-By')) // Output: alien-middleware
 
 Even if a middleware returns an immutable `Response` (e.g. from a `fetch()` call), your _response callback_ can still modify the headers. We make sure to clone the response before processing it with any response callbacks.
 
+#### Non-Blocking Response Callbacks
+
+To ensure the client receives a response as soon as possible, your response callbacks should avoid using `await` unless absolutely necessary. Prefer using `context.waitUntil()` to register independent promises that shouldn't block the response from being sent.
+
+```typescript
+const app = chain().use(context => {
+  context.onResponse(async response => {
+    // ❌ Bad! This blocks the response from being sent.
+    await myLoggingService.logResponse(response)
+
+    // ❌ Bad! This may be interrupted by serverless runtimes.
+    myLoggingService.logResponse(response).catch(console.error)
+
+    // ✅ Good! This doesn't block the response from being sent.
+    context.waitUntil(myLoggingService.logResponse(response))
+  })
+})
+```
+
 ### Merging a Middleware Chain
 
 By passing a middleware chain to `.use()`, you can merge it with the existing chain. Its middlewares will be executed _after_ any existing middlewares in this chain and _before_ any new middlewares you add later.