alien-middleware 0.6.0 → 0.7.0

package/dist/chunk-HZDENULC.js

@@ -0,0 +1,29 @@
+// node_modules/.pnpm/radashi@12.5.0-beta.6d5c035/node_modules/radashi/dist/radashi.js
+function noop() {
+}
+var isArray = /* @__PURE__ */ (() => Array.isArray)();
+function isFunction(value) {
+  return typeof value === "function";
+}
+
+// src/url.ts
+var urlDescriptor = {
+  configurable: true,
+  get() {
+    const url = new URL(this.request.url);
+    Object.defineProperty(this, "url", { value: url });
+    return url;
+  }
+};
+function defineParsedURL(context) {
+  if (!("url" in context)) {
+    Object.defineProperty(context, "url", urlDescriptor);
+  }
+}
+
+export {
+  noop,
+  isArray,
+  isFunction,
+  defineParsedURL
+};

package/dist/{index-CuxbHrbf.d.ts → index-DEMeaByn.d.ts}

@@ -1,5 +1,5 @@
+import { Any, noop } from 'radashi';
 import { AdapterRequestContext, HattipHandler } from '@hattip/core';
-import { Any } from 'radashi';
 
 type RequestEnvPlugin = {
     /**
@@ -55,6 +55,7 @@ type RequestContext<TProperties extends object = never, TEnv extends object = an
  * When type `T` is `never`, a default context is returned.
  */
 type MiddlewareContext<T extends MiddlewareChain> = [T] extends [never] ? RequestContext<{}, {}, unknown> : RequestContext<Properties<T>, Env<T>, Platform<T>>;
+type IsolatedContext<T extends MiddlewareChain> = RequestContext<InputProperties<T>, InputEnv<T>, Platform<T>>;
 type Awaitable<T> = T | Promise<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>;
@@ -74,7 +75,7 @@ type ExtractMiddleware<T extends MiddlewareChain> = Middleware<Properties<T>, En
 type Merge<TSource extends object, TOverrides extends object | undefined> = {} & (TOverrides extends object ? {
     [K in keyof TSource | keyof TOverrides]: K extends keyof TOverrides ? TOverrides[K] : K extends keyof TSource ? TSource[K] : never;
 } : TSource);
-type ApplyRequestPlugin<TParent extends MiddlewareChain, TPlugin extends RequestPlugin> = {
+type ApplyRequestPlugin<TParent extends MiddlewareChain, TPlugin extends RequestPlugin> = {} & {
     properties: Merge<Properties<TParent>, Omit<TPlugin, keyof RequestEnvPlugin>>;
     env: Merge<Env<TParent>, TPlugin['env']>;
 };
@@ -83,7 +84,10 @@ type ApplyRequestPlugin<TParent extends MiddlewareChain, TPlugin extends Request
  * chain, it's treated as a nested chain, which won't leak its plugins into the
  * parent chain.
  */
-type ApplyMiddleware<TParent extends MiddlewareChain, TMiddleware> = TMiddleware extends MiddlewareChain ? RequestHandler<Inputs<TParent>, Current<TParent>, Platform<TParent>> : TMiddleware extends () => Awaitable<infer TPlugin extends RequestPlugin> ? RequestHandler<Inputs<TParent>, ApplyRequestPlugin<TParent, TPlugin>, Platform<TParent>> : RequestHandler<Inputs<TParent>, Current<TParent>, Platform<TParent>>;
+type ApplyMiddleware<TFirst extends MiddlewareChain, TSecond extends Middleware<Properties<TFirst>, Env<TFirst>, Platform<TFirst>>> = RequestHandler<Inputs<TFirst>, TSecond extends MiddlewareChain ? {
+    properties: Merge<Properties<TFirst>, Properties<TSecond>>;
+    env: Merge<Env<TFirst>, Env<TSecond>>;
+} : TSecond extends () => Awaitable<infer TResult> ? TResult extends RequestPlugin ? ApplyRequestPlugin<TFirst, TResult> : Current<TFirst> : Current<TFirst>, Platform<TFirst>>;
 type EmptyMiddlewareChain = MiddlewareChain<{
     properties: {};
     env: {};
@@ -92,10 +96,6 @@ type EmptyMiddlewareChain = MiddlewareChain<{
     env: {};
 }, unknown>;
 type ApplyFirstMiddleware<T extends Middleware> = T extends MiddlewareChain ? T : ApplyMiddleware<EmptyMiddlewareChain, T>;
-type MergeMiddleware<TFirst extends MiddlewareChain, TSecond extends Middleware<Properties<TFirst>, Env<TFirst>, Platform<TFirst>>> = RequestHandler<Inputs<TFirst>, TSecond extends MiddlewareChain ? {
-    properties: Merge<Properties<TFirst>, Properties<TSecond>>;
-    env: Merge<Env<TFirst>, Env<TSecond>>;
-} : TSecond extends () => Awaitable<infer TPlugin extends RequestPlugin> ? ApplyRequestPlugin<TFirst, TPlugin> : Current<TFirst>, Platform<TFirst>>;
 type RouteMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'OPTIONS' | 'HEAD';
 type RouterContext<T extends MiddlewareChain = any, TPathParams extends object = any, TMethod extends RouteMethod = RouteMethod> = MiddlewareContext<T> & {
     params: TPathParams;
@@ -127,18 +127,17 @@ TPlatform = any> {
      * treated as a response middleware. Otherwise, it will be treated as a
      * request middleware.
      *
+     * If a middleware chain is given, its middlewares will be executed after any
+     * existing middlewares in this chain.
+     *
      * @returns a new `MiddlewareChain` instance
      */
     use<const TMiddleware extends ExtractMiddleware<this>>(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.
-     *
-     * For ease of use, this method may be given a middleware function, which
-     * short-circuits to the `use` method. You should prefer using the `use`
-     * method directly, if possible.
+     * Create a middleware function that encapsulates this middleware chain, so
+     * any modifications it makes to the request context are not leaked.
      */
-    merge<TMiddleware extends ExtractMiddleware<this>>(chain: TMiddleware): MergeMiddleware<this, TMiddleware>;
+    isolate(): ((ctx: IsolatedContext<this>) => Promise<Response | void>) | typeof noop;
 }
 declare function chain<TProperties extends object = {}, TEnv extends object = {}, TPlatform = unknown>(): MiddlewareChain<{
     env: TEnv;
@@ -149,4 +148,4 @@ declare function chain<TProperties extends object = {}, TEnv extends object = {}
 }, TPlatform>;
 declare function chain<const T extends Middleware = Middleware>(middleware: T): ApplyFirstMiddleware<T>;
 
-export { type ApplyMiddleware as A, type EmptyMiddlewareChain as E, MiddlewareChain as M, type RouteHandler as R, type MiddlewareContext as a, type RouteMethod as b, type RouterContext as c, chain as d, type ExtractMiddleware as e, type MergeMiddleware as f, type Middleware as g, type RequestContext as h, type RequestHandler as i, type RequestMiddleware as j, type RequestPlugin as k, type ResponseMiddleware as l };
+export { type ApplyMiddleware as A, type EmptyMiddlewareChain as E, MiddlewareChain as M, type RouteHandler as R, type MiddlewareContext as a, type RouteMethod as b, type RouterContext as c, chain as d, type ExtractMiddleware as e, type Middleware as f, type RequestContext as g, type RequestHandler as h, type RequestMiddleware as i, type RequestPlugin as j, type ResponseMiddleware as k };

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-export { A as ApplyMiddleware, e as ExtractMiddleware, f as MergeMiddleware, g as Middleware, M as MiddlewareChain, a as MiddlewareContext, h as RequestContext, i as RequestHandler, j as RequestMiddleware, k as RequestPlugin, l as ResponseMiddleware, d as chain } from './index-CuxbHrbf.js';
-import '@hattip/core';
 import 'radashi';
+export { A as ApplyMiddleware, e as ExtractMiddleware, f as Middleware, M as MiddlewareChain, a as MiddlewareContext, g as RequestContext, h as RequestHandler, i as RequestMiddleware, j as RequestPlugin, k as ResponseMiddleware, d as chain } from './index-DEMeaByn.js';
+import '@hattip/core';

package/dist/index.js

@@ -1,16 +1,14 @@
+import {
+  defineParsedURL,
+  isFunction,
+  noop
+} from "./chunk-HZDENULC.js";
+
 // src/index.ts
 var kRequestChain = Symbol("requestChain");
 var kResponseChain = Symbol("responseChain");
 var kIgnoreNotFound = Symbol("ignoreNotFound");
 var kMiddlewareCache = Symbol("middlewareCache");
-var urlDescriptor = {
-  configurable: true,
-  get() {
-    const url = new URL(this.request.url);
-    Object.defineProperty(this, "url", { value: url });
-    return url;
-  }
-};
 var MiddlewareChain = class _MiddlewareChain {
   [kRequestChain] = [];
   [kResponseChain] = [];
@@ -19,9 +17,18 @@ var MiddlewareChain = class _MiddlewareChain {
    * treated as a response middleware. Otherwise, it will be treated as a
    * request middleware.
    *
+   * If a middleware chain is given, its middlewares will be executed after any
+   * existing middlewares in this chain.
+   *
    * @returns a new `MiddlewareChain` instance
    */
   use(middleware) {
+    if (middleware instanceof _MiddlewareChain) {
+      return createHandler(
+        [...this[kRequestChain], ...middleware[kRequestChain]],
+        [...this[kResponseChain], ...middleware[kResponseChain]]
+      );
+    }
     let requestChain = this[kRequestChain];
     let responseChain = this[kResponseChain];
     if (middleware.length < 2) {
@@ -32,30 +39,23 @@ var MiddlewareChain = class _MiddlewareChain {
     return createHandler(requestChain, responseChain);
   }
   /**
-   * Merge two middleware chains. The middlewares from the second chain will be
-   * executed after the middlewares from the first chain.
-   *
-   * For ease of use, this method may be given a middleware function, which
-   * short-circuits to the `use` method. You should prefer using the `use`
-   * method directly, if possible.
+   * Create a middleware function that encapsulates this middleware chain, so
+   * any modifications it makes to the request context are not leaked.
    */
-  merge(chain2) {
-    if (chain2 instanceof _MiddlewareChain) {
-      return createHandler(
-        [...this[kRequestChain], ...chain2[kRequestChain]],
-        [...this[kResponseChain], ...chain2[kResponseChain]]
-      );
-    }
-    return this.use(chain2);
+  isolate() {
+    return isFunction(this) ? (ctx) => this(ctx) : noop;
   }
 };
 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);
-    }
+    defineParsedURL(context);
+    const { passThrough } = context;
+    let shouldPassThrough = false;
+    context.passThrough = () => {
+      shouldPassThrough = true;
+    };
     const cache = context[kMiddlewareCache] ||= /* @__PURE__ */ new Set();
     let response;
     let env;
@@ -68,17 +68,23 @@ function createHandler(requestChain, responseChain) {
       if (result instanceof Promise) {
         result = await result;
       }
+      if (shouldPassThrough) {
+        break;
+      }
       if (result) {
         if (result instanceof Response) {
           response = result;
           break;
         }
         for (const key in result) {
-          const descriptor = Object.getOwnPropertyDescriptor(result, key);
           if (key === "env") {
             env ||= createExtendedEnv(context);
-            Object.defineProperty(env, key, descriptor);
+            Object.defineProperties(
+              env,
+              Object.getOwnPropertyDescriptors(result.env)
+            );
           } else {
+            const descriptor = Object.getOwnPropertyDescriptor(result, key);
             descriptor.configurable = false;
             Object.defineProperty(context, key, descriptor);
           }
@@ -90,6 +96,12 @@ function createHandler(requestChain, responseChain) {
         return;
       }
       response = new Response("Not Found", { status: 404 });
+      if (shouldPassThrough) {
+        passThrough();
+        return response;
+      }
+    } else if (response.type !== "default") {
+      response = new Response(response.body, response);
     }
     for (const middleware of responseChain) {
       if (cache.has(middleware)) {
@@ -122,8 +134,8 @@ function chain(middleware) {
   if (middleware instanceof MiddlewareChain) {
     return middleware;
   }
-  const handler = new MiddlewareChain();
-  return middleware ? handler.use(middleware) : handler;
+  const empty = new MiddlewareChain();
+  return middleware ? empty.use(middleware) : empty;
 }
 export {
   MiddlewareChain,

package/dist/router.d.ts

@@ -1,8 +1,8 @@
 import { InferParams } from 'pathic';
-import { M as MiddlewareChain, E as EmptyMiddlewareChain, a as MiddlewareContext, R as RouteHandler, b as RouteMethod } from './index-CuxbHrbf.js';
-export { c as RouterContext } from './index-CuxbHrbf.js';
-import '@hattip/core';
+import { M as MiddlewareChain, E as EmptyMiddlewareChain, a as MiddlewareContext, R as RouteHandler, b as RouteMethod } from './index-DEMeaByn.js';
+export { c as RouterContext } from './index-DEMeaByn.js';
 import 'radashi';
+import '@hattip/core';
 
 type OneOrMany<T> = T | readonly T[];
 type Router<T extends MiddlewareChain = any> = ReturnType<typeof routes<T>>;

package/dist/router.js

@@ -1,21 +1,16 @@
-// src/router.ts
-import { compilePaths } from "pathic";
-
-// node_modules/.pnpm/radashi@12.5.0-beta.6d5c035/node_modules/radashi/dist/radashi.js
-var isArray = /* @__PURE__ */ (() => Array.isArray)();
-var asyncIteratorSymbol = (
-  /* c8 ignore next */
-  Symbol.asyncIterator || Symbol.for("Symbol.asyncIterator")
-);
-function isFunction(value) {
-  return typeof value === "function";
-}
+import {
+  defineParsedURL,
+  isArray,
+  isFunction
+} from "./chunk-HZDENULC.js";
 
 // src/router.ts
+import { compilePaths } from "pathic";
 function routes(middlewares) {
   const paths = [];
   const filters = [];
   const handlers = [];
+  let matcher;
   function use(method, path, handler) {
     if (isFunction(path)) {
       paths.push(method);
@@ -28,13 +23,15 @@ function routes(middlewares) {
       );
       handlers.push(handler);
     }
+    matcher = void 0;
     return router;
   }
-  let matcher;
   function router(context) {
+    defineParsedURL(context);
+    const { request, url } = context;
+    const method = request.method;
     matcher ||= compilePaths(paths);
-    const method = context.request.method;
-    return matcher(context.request.path, (index, params) => {
+    return matcher(url.pathname, (index, params) => {
       if (!filters[index] || filters[index](method)) {
         context.method = method;
         context.params = params;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "alien-middleware",
   "type": "module",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -29,13 +29,14 @@
     "@alloc/prettier-config": "^1.0.0",
     "@hattip/core": "^0.0.49",
     "@types/node": "^22.15.3",
+    "@vitest/coverage-v8": "^3.1.3",
     "prettier": "^3.5.3",
     "radashi": "12.5.0-beta.6d5c035",
     "rimraf": "^6.0.1",
     "tsc-lint": "^0.1.9",
     "tsup": "^8.4.0",
     "typescript": "^5.8.3",
-    "vitest": "^3.1.2"
+    "vitest": "^3.1.3"
   },
   "dependencies": {
     "pathic": "^0.1.6"