alien-middleware 0.3.0 → 0.4.0

package/dist/index.d.ts

@@ -39,7 +39,7 @@ type RequestContext<TProperties extends object = any, TEnv extends object = any,
 type Awaitable<T> = T | PromiseLike<T>;
 type RequestMiddleware<T extends MiddlewareChain = MiddlewareChain> = (context: RequestContext<InputProperties<T>, InputEnv<T>, Platform<T>>) => Awaitable<Response | RequestPlugin | void>;
 type ResponseMiddleware<T extends MiddlewareChain = MiddlewareChain> = (context: RequestContext<InputProperties<T>, InputEnv<T>, Platform<T>>, response: Response) => Awaitable<Response | void>;
-type RequestHandler<TInputs extends MiddlewareTypes, TCurrent extends MiddlewareTypes, TPlatform> = HattipHandler<TPlatform> & MiddlewareChain<TInputs, TCurrent, TPlatform>;
+type RequestHandler<TInputs extends MiddlewareTypes = any, TCurrent extends MiddlewareTypes = any, TPlatform = any> = HattipHandler<TPlatform> & MiddlewareChain<TInputs, TCurrent, TPlatform>;
 /**
  * Either a request middleware or a response middleware.
  *
@@ -62,6 +62,10 @@ type ApplyFirstMiddleware<T extends Middleware> = ApplyMiddleware<MiddlewareChai
     properties: {};
     env: {};
 }, unknown>, T>;
+type MergeMiddlewareChains<TFirst extends MiddlewareChain, TSecond extends MiddlewareChain<Current<TFirst>, any, Platform<TFirst>>> = RequestHandler<Inputs<TFirst>, {
+    properties: Merge<Properties<TFirst>, Properties<TSecond>>;
+    env: Merge<Env<TFirst>, Env<TSecond>>;
+}, Platform<TFirst>>;
 
 declare const kRequestChain: unique symbol;
 declare const kResponseChain: unique symbol;
@@ -90,6 +94,11 @@ TPlatform = any> {
      * @returns a new `MiddlewareChain` instance
      */
     use<const TMiddleware extends Middleware<TCurrent['properties'], TCurrent['env'], TPlatform>>(middleware: TMiddleware): ApplyMiddleware<this, TMiddleware>;
+    /**
+     * Merge two middleware chains. The middlewares from the second chain will be
+     * executed after the middlewares from the first chain.
+     */
+    merge<TChain extends MiddlewareChain<TCurrent, any, TPlatform>>(chain: TChain): MergeMiddlewareChains<this, TChain>;
 }
 declare function chain<TProperties extends object = {}, TEnv extends object = {}, TPlatform = unknown>(): MiddlewareChain<{
     env: TEnv;

package/dist/index.js

@@ -23,7 +23,7 @@ var urlDescriptor = {
     return url;
   }
 };
-var MiddlewareChain = class _MiddlewareChain {
+var MiddlewareChain = class {
   [kRequestChain] = [];
   [kResponseChain] = [];
   /**
@@ -41,66 +41,84 @@ var MiddlewareChain = class _MiddlewareChain {
     } else {
       responseChain = [...responseChain, middleware];
     }
-    async function handler(parentContext) {
-      const context = Object.create(parentContext);
-      context[kIgnoreNotFound] = true;
-      if (!("url" in context)) {
-        Object.defineProperty(context, "url", urlDescriptor);
+    return createHandler(requestChain, responseChain);
+  }
+  /**
+   * Merge two middleware chains. The middlewares from the second chain will be
+   * executed after the middlewares from the first chain.
+   */
+  merge(chain2) {
+    return createHandler(
+      [...this[kRequestChain], ...chain2[kRequestChain]],
+      [...this[kResponseChain], ...chain2[kResponseChain]]
+    );
+  }
+};
+function createHandler(requestChain, responseChain) {
+  async function handler(parentContext) {
+    const context = Object.create(parentContext);
+    context[kIgnoreNotFound] = true;
+    if (!("url" in context)) {
+      Object.defineProperty(context, "url", urlDescriptor);
+    }
+    const cache = context[kMiddlewareCache] ||= /* @__PURE__ */ new Set();
+    let response;
+    let env;
+    for (const middleware of requestChain) {
+      if (cache.has(middleware)) {
+        continue;
       }
-      const cache = context[kMiddlewareCache] ||= /* @__PURE__ */ new Set();
-      let response;
-      let env;
-      for (const middleware2 of requestChain) {
-        if (cache.has(middleware2)) {
-          continue;
-        }
-        cache.add(middleware2);
-        let result = middleware2(context);
-        if (isPromise(result)) {
-          result = await result;
+      cache.add(middleware);
+      let result = middleware(context);
+      if (isPromise(result)) {
+        result = await result;
+      }
+      if (result) {
+        if (result instanceof Response) {
+          response = result;
+          break;
         }
-        if (result) {
-          if (result instanceof Response) {
-            response = result;
-            break;
-          }
-          if (result.define) {
-            Object.assign(context, result.define);
-          }
-          if (result.env) {
-            env ||= createExtendedEnv(context);
-            Object.assign(env, result.env);
+        if (result.define) {
+          for (const key in result.define) {
+            Object.defineProperty(context, key, {
+              ...Object.getOwnPropertyDescriptor(result.define, key),
+              configurable: false
+            });
           }
         }
-      }
-      if (!response) {
-        if (parentContext[kIgnoreNotFound]) {
-          return;
+        if (result.env) {
+          env ||= createExtendedEnv(context);
+          Object.assign(env, result.env);
         }
-        response = new Response("Not Found", { status: 404 });
       }
-      for (const middleware2 of responseChain) {
-        if (cache.has(middleware2)) {
-          continue;
-        }
-        cache.add(middleware2);
-        let result = middleware2(context, response);
-        if (isPromise(result)) {
-          result = await result;
-        }
-        if (result && result instanceof Response) {
-          response = result;
-          continue;
-        }
+    }
+    if (!response) {
+      if (parentContext[kIgnoreNotFound]) {
+        return;
       }
-      return response;
+      response = new Response("Not Found", { status: 404 });
     }
-    Object.setPrototypeOf(handler, _MiddlewareChain.prototype);
-    handler[kRequestChain] = requestChain;
-    handler[kResponseChain] = responseChain;
-    return handler;
+    for (const middleware of responseChain) {
+      if (cache.has(middleware)) {
+        continue;
+      }
+      cache.add(middleware);
+      let result = middleware(context, response);
+      if (isPromise(result)) {
+        result = await result;
+      }
+      if (result && result instanceof Response) {
+        response = result;
+        continue;
+      }
+    }
+    return response;
   }
-};
+  Object.setPrototypeOf(handler, MiddlewareChain.prototype);
+  handler[kRequestChain] = requestChain;
+  handler[kResponseChain] = responseChain;
+  return handler;
+}
 function createExtendedEnv(context) {
   const env = /* @__PURE__ */ Object.create(null);
   const superEnv = context.env;

package/package.json

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

package/readme.md

@@ -82,6 +82,14 @@ server.listen(3000, () => {
 > If no middleware in the chain returns a `Response`, a `404 Not Found` response
 > is automatically returned.
 
+#### Middlewares are deduplicated.
+
+If you add the same middleware multiple times, it will only run once. This is a safety measure that allows you to use the same middleware in different places without worrying about it running multiple times.
+
+```typescript
+const app = chain().use(myMiddleware).use(myMiddleware)
+```
+
 ### Request Middleware
 
 Request middleware runs sequentially before a `Response` is generated.
@@ -203,6 +211,16 @@ const finalApp = chain().use(innerChain).use(outerMiddleware)
 
 If a nested chain does not return a `Response`, execution continues with the next middleware in the outer chain.
 
+### Merging Chains
+
+You can merge two middleware chains using the `merge` method. This is useful if you want to combine middleware from multiple files or modules.
+
+```typescript
+const mergedApp = chain().use(middleware1).merge(chain().use(middleware2))
+// …is equivalent to…
+const mergedApp = chain().use(middleware1).use(middleware2)
+```
+
 ### Safe Environment Variables
 
 When writing a Hattip handler without this package, the `context.env()` method is inherently unsafe. Its return type is always `string | undefined`, which means you either need to write defensive checks or use type assertions. Neither is ideal.