alien-middleware 0.1.0 → 0.2.0

package/dist/index.js

@@ -66,7 +66,7 @@ var MiddlewareChain = class _MiddlewareChain {
         if (parentContext[kIgnoreNotFound]) {
           return;
         }
-        return new Response("Not Found", { status: 404 });
+        response = new Response("Not Found", { status: 404 });
       }
       for (const middleware2 of responseChain) {
         if (cache.has(middleware2)) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "alien-middleware",
   "type": "module",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "exports": {
     "types": "./dist/index.d.ts",
     "default": "./dist/index.js"

package/readme.md

@@ -51,7 +51,7 @@ const secondMiddleware = (ctx: RequestContext) => {
 }
 
 // Add middleware sequentially
-const finalApp = app.use(firstMiddleware).use(secondMiddleware)
+const app = chain().use(firstMiddleware).use(secondMiddleware)
 ```
 
 > [!NOTE]
@@ -59,29 +59,28 @@ const finalApp = app.use(firstMiddleware).use(secondMiddleware)
 
 ### Executing the Chain
 
-To run the middleware chain, call the chain instance itself with a context object. This object typically comes from an adapter like Hattip's [Node adapter](https://www.npmjs.com/package/@hattip/adapter-node).
+To run the middleware chain, pass it to a Hattip adapter like the [Node adapter](https://www.npmjs.com/package/@hattip/adapter-node). The middleware chain is a valid Hattip handler.
 
 ```typescript
-// Simplified context for demonstration (requires necessary imports like 'noop' if run directly)
-const context: AdapterRequestContext = {
-  request: new Request('http://localhost/test'),
-  ip: '127.0.0.1',
-  platform: {},
-  waitUntil: (promise: Promise<any>) => {},
-  passThrough: () => {},
-  env: (key: string) => undefined, // Basic env function
-}
+import { createServer } from '@hattip/adapter-node'
+
+const app = chain()
+  .use(mySessionMiddleware)
+  .use(myAuthMiddleware)
+  .use(myLoggerMiddleware)
 
-// Execute the chain
-const response = await finalApp(context) // Assuming finalApp from previous example
+// Create a server
+const server = createServer(app)
 
-console.log(await response.text()) // Output: Hello from middleware!
-console.log(response.status) // Output: 200
+// Start the server
+server.listen(3000, () => {
+  console.log('Server is running on port 3000')
+})
 ```
 
 > [!NOTE]
 > If no middleware in the chain returns a `Response`, a `404 Not Found` response
-> is automatically returned, except for nested chains.
+> is automatically returned.
 
 ### Request Middleware
 
@@ -115,18 +114,9 @@ Request middleware runs sequentially before a `Response` is generated.
     return new Response(`Hello, ${ctx.user.name}!`)
   }
 
-  const userApp = app.use(addUser).use(greetUser)
+  const app = chain().use(addUser).use(greetUser)
   ```
 
-  > [!NOTE]
-  > If you're wondering why you need to return a `{ define: { … } }` object
-  > (rather than using simple assignment), it's because TypeScript is unable to
-  > infer the type of the context object downstream if you don't do this.
-  >
-  > Another thing to note is you don't typically define middlewares outside the
-  > `.use(…)` call expression, since that requires you to unnecessarily declare
-  > the type of the context object. It's better to define them inline.
-
 - **Extending Environment:** Return an object with an `env` property to add environment variables accessible via `ctx.env()`.
 
   ```typescript
@@ -139,15 +129,25 @@ Request middleware runs sequentially before a `Response` is generated.
     console.log('API Key:', key) // Output: API Key: secret123
   }
 
-  const envApp = app.use(addApiKey).use(useApiKey)
+  const app = chain().use(addApiKey).use(useApiKey)
   ```
 
+> [!NOTE]
+> If you're wondering why you need to return a `{ define: { … } }` object
+> (rather than simply assigning to the context object), it's because TypeScript
+> is unable to infer the type of the context object downstream if you don't do
+> it like this.
+>
+> Another thing to note is you don't typically define middlewares outside the
+> `.use(…)` call expression, since that requires you to unnecessarily declare
+> the type of the context object. It's better to define them inline.
+
 ### Response Middleware
 
 Response middleware runs _after_ a `Response` has been generated by a request middleware or the final handler. It receives both the context and the generated `Response`.
 
 ```typescript
-const addHeader = (ctx: RequestContext, response: Response) => {
+const poweredByMiddleware = (ctx: RequestContext, response: Response) => {
   response.headers.set('X-Powered-By', 'alien-middleware')
 }
 
@@ -155,12 +155,11 @@ const mainHandler = (ctx: RequestContext) => {
   return new Response('Main content')
 }
 
-// `addHeader` runs after `mainHandler` generates a response
-const headerApp = app.use(mainHandler).use(addHeader)
+// `poweredByMiddleware` runs after `mainHandler` generates a response
+const app = chain().use(mainHandler).use(poweredByMiddleware)
 
-// Assuming `context` is defined as in the "Executing the Chain" example
-const responseWithHeader = await headerApp(context)
-console.log(responseWithHeader.headers.get('X-Powered-By')) // Output: alien-middleware
+const response = await app({…})
+console.log(response.headers.get('X-Powered-By')) // Output: alien-middleware
 ```
 
 > [!NOTE]
@@ -168,6 +167,11 @@ console.log(responseWithHeader.headers.get('X-Powered-By')) // Output: alien-mid
 > They can only inspect the `Response` or replace it by returning a new
 > `Response`.
 
+Your response middlewares will run even if no `Response` is generated by the
+request middlewares, **except** when the middleware chain is nested inside
+another chain, since the outer chain will still have a chance to return a
+`Response`.
+
 ### Nesting Chains
 
 You can compose middleware by nesting chains using `.use()`. Context modifications (`define`, `env`) within a nested chain are scoped to that chain and do not affect middleware outside of it.
@@ -189,15 +193,12 @@ const outerMiddleware = (ctx: RequestContext) => {
   return new Response('Finished')
 }
 
-const nestedApp = app.use(innerChain).use(outerMiddleware)
-
-// Assuming `context` is defined as in the "Executing the Chain" example
-await nestedApp(context)
-// Output:
-// Inner chain start
-// Accessing inner data: secret
-// Outer middleware after inner chain
-// innerData is correctly scoped.
+const finalApp = chain().use(innerChain).use(outerMiddleware)
+// Output when executing the finalApp chain:
+//   Inner chain start
+//   Accessing inner data: secret
+//   Outer middleware after inner chain
+//   innerData is correctly scoped.
 ```
 
 If a nested chain does not return a `Response`, execution continues with the next middleware in the outer chain.