alien-middleware 0.9.0 → 0.9.1

package/dist/{index-vRvlpUCy.d.ts → index-B5T_qCSA.d.ts}

@@ -1,4 +1,3 @@
-import { Any, noop } from 'radashi';
 import { AdapterRequestContext, HattipHandler } from '@hattip/core';
 import { InferParams } from 'pathic';
 
@@ -7,10 +6,7 @@ type Eval<T> = {} & {
 };
 type Awaitable<T> = T | Promise<T>;
 type OneOrMany<T> = T | readonly T[];
-/**
- * Converts a type `T` to something that can be intersected with an object.
- */
-type Intersectable<T extends object> = [T] extends [never] ? {} : [T] extends [Any] ? Record<PropertyKey, any> : T;
+type CastNever<T, U> = [T] extends [never] ? U : T;
 
 type Keys<T> = T extends any ? keyof T : never;
 type IsOptional<T, K> = K extends keyof T ? T[K] extends Required<T>[K] ? false : true : true;
@@ -21,8 +17,8 @@ type MergeProperty<TSource, TOverrides, K> = (K extends keyof TOverrides ? Possi
  *
  * **FIXME:** Optional properties resolve as `foo: Foo | undefined` instead of `foo?: Foo`.
  */
-type Merge<TSource extends object, TOverrides extends object | undefined> = Eval<Omit<TSource, Keys<TOverrides>> & {
-    [K in Keys<TOverrides>]: TOverrides extends any ? MergeProperty<TSource, TOverrides, K> : never;
+type Merge<TSource extends object, TOverrides extends object | undefined> = Eval<Omit<CastNever<TSource, {}>, Keys<TOverrides>> & {
+    [K in Keys<TOverrides>]: TOverrides extends any ? MergeProperty<CastNever<TSource, {}>, TOverrides, K> : never;
 }>;
 
 type RequestEnvPlugin = {
@@ -67,13 +63,13 @@ type AnyMiddlewareTypes = {
     platform: any;
 };
 type AnyMiddlewareChain = MiddlewareChain<AnyMiddlewareTypes>;
-type Inputs<T extends AnyMiddlewareChain> = T['$']['initial'];
+type Inputs<T extends AnyMiddlewareChain> = T['$MiddlewareChain']['initial'];
 type InputProperties<T extends AnyMiddlewareChain> = Inputs<T>['properties'];
 type InputEnv<T extends AnyMiddlewareChain> = Inputs<T>['env'];
-type Current<T extends AnyMiddlewareChain> = T['$']['current'];
+type Current<T extends AnyMiddlewareChain> = T['$MiddlewareChain']['current'];
 type Properties<T extends AnyMiddlewareChain> = Current<T>['properties'];
 type Env<T extends AnyMiddlewareChain> = Current<T>['env'];
-type Platform<T extends AnyMiddlewareChain> = T['$']['platform'];
+type Platform<T extends AnyMiddlewareChain> = T['$MiddlewareChain']['platform'];
 interface HattipContext<TPlatform, TEnv extends object> extends AdapterRequestContext<TPlatform> {
     /**
      * The `request.url` string parsed into a `URL` object. Parsing is performed
@@ -96,7 +92,7 @@ interface HattipContext<TPlatform, TEnv extends object> extends AdapterRequestCo
  * should prefer `RequestContext<any>` over `RequestContext` (no type
  * parameters), as the default type is stricter.
  */
-type RequestContext<TEnv extends object = any, TProperties extends object = never, TPlatform = any> = HattipContext<TPlatform, TEnv> & Intersectable<TProperties>;
+type RequestContext<TEnv extends object = any, TProperties extends object = never, TPlatform = any> = HattipContext<TPlatform, TEnv> & CastNever<TProperties, unknown>;
 /**
  * Extract a `RequestContext` type from a `MiddlewareChain` type.
  *
@@ -115,11 +111,20 @@ interface RequestHandler<T extends MiddlewareTypes = any> extends HattipHandler<
  * response middleware. This means it will run *after* a `Response` is generated
  * by a request middleware.
  */
-type Middleware<TEnv extends object = any, TProperties extends object = any, TPlatform = any> = (context: RequestContext<TEnv, TProperties, TPlatform>, response: Response) => Awaitable<Response | RequestPlugin | void>;
+type Middleware<TEnv extends object = any, TProperties extends object = any, TPlatform = any> = {
+    (context: RequestContext<TEnv, TProperties, TPlatform>, response: Response): Awaitable<Response | RequestPlugin | void>;
+    /** This property won't exist at runtime. It contains type information for inference purposes. */
+    $Middleware?: MiddlewareTypes & {
+        initial: {
+            env: TEnv;
+            properties: TProperties;
+        };
+    };
+};
 /**
  * Extract a `Middleware` type from a `MiddlewareChain` type.
  */
-type ExtractMiddleware<T extends MiddlewareChain> = Middleware<Env<T>, Properties<T>, Platform<T>>;
+type ExtractMiddleware<T extends MiddlewareChain> = [T] extends [never] ? Middleware<{}, {}, any> : Middleware<Env<T>, Properties<T>, Platform<T>>;
 /**
  * Merge a request plugin into a middleware chain.
  */
@@ -129,20 +134,29 @@ type ApplyMiddlewareResult<TParent extends MiddlewareChain, TResult> = Eval<{
     } ? TEnv : undefined>;
     properties: Merge<Properties<TParent>, TResult extends RequestPlugin ? Omit<TResult, keyof RequestEnvPlugin> : undefined>;
 }>;
+type ApplyMiddlewareOutputs<TFirst extends MiddlewareChain, TSecond extends Middleware> = TSecond extends MiddlewareChain ? {
+    env: Merge<Env<TFirst>, Env<TSecond>>;
+    properties: Merge<Properties<TFirst>, Properties<TSecond>>;
+} : TSecond extends (...args: any[]) => Awaitable<infer TResult> ? ApplyMiddlewareResult<TFirst, TResult> : Current<TFirst>;
+type MiddlewareInputs<T extends Middleware> = T extends Middleware<infer TEnv, infer TProperties> ? {
+    env: TEnv;
+    properties: TProperties;
+} : never;
+type MiddlewarePlatform<T extends Middleware> = T extends Middleware<any, any, infer TPlatform> ? TPlatform : never;
 /**
  * This applies a middleware to a chain. If the type `TMiddleware` is itself a
  * chain, it's treated as a nested chain, which won't leak its plugins into the
  * parent chain.
+ *
+ * The `TFirst` type is allowed to be `never`, which results in the middleware's
+ * output types being used as the request handler's input types.
  */
-type ApplyMiddleware<TFirst extends MiddlewareChain, TSecond extends Middleware<Env<TFirst>, Properties<TFirst>, Platform<TFirst>>> = (TSecond extends MiddlewareChain ? {
-    env: Merge<Env<TFirst>, Env<TSecond>>;
-    properties: Merge<Properties<TFirst>, Properties<TSecond>>;
-} : TSecond extends (...args: any[]) => Awaitable<infer TResult> ? ApplyMiddlewareResult<TFirst, TResult> : Current<TFirst>) extends infer TOutputs extends MiddlewareTypes['current'] ? RequestHandler<{
-    initial: Inputs<TFirst>;
-    current: TOutputs;
-    platform: Platform<TFirst>;
+type ApplyMiddleware<TFirst extends MiddlewareChain, TSecond extends Middleware> = ApplyMiddlewareOutputs<TFirst, TSecond> extends infer TCurrent extends MiddlewareTypes['current'] ? RequestHandler<{
+    initial: CastNever<Inputs<TFirst>, MiddlewareInputs<TSecond>>;
+    current: TCurrent;
+    platform: CastNever<Platform<TFirst>, MiddlewarePlatform<TSecond>>;
 }> : never;
-type EmptyMiddlewareChain = MiddlewareChain<{
+type EmptyMiddlewareChain<TPlatform = unknown> = MiddlewareChain<{
     initial: {
         env: {};
         properties: {};
@@ -151,18 +165,18 @@ type EmptyMiddlewareChain = MiddlewareChain<{
         env: {};
         properties: {};
     };
-    platform: unknown;
+    platform: TPlatform;
 }>;
-type ApplyFirstMiddleware<T extends Middleware> = T extends MiddlewareChain ? T : ApplyMiddleware<EmptyMiddlewareChain, T>;
+type ApplyFirstMiddleware<T extends Middleware> = T extends MiddlewareChain ? T : ApplyMiddleware<EmptyMiddlewareChain<MiddlewarePlatform<T>>, T>;
 type RouteMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'OPTIONS' | 'HEAD' | (string & {});
-type RouteContext<T extends RouterTypes = any, TPathParams extends object = any, TMethod extends RouteMethod = RouteMethod> = MiddlewareContext<ApplyMiddleware<MiddlewareChain<T['$']>, () => {
+type RouteContext<T extends RouterTypes = any, TPathParams extends object = any, TMethod extends RouteMethod = RouteMethod> = MiddlewareContext<ApplyMiddleware<MiddlewareChain<T['$Router']>, () => {
     params: TPathParams;
     method: TMethod;
 }>>;
 type RouteHandler<T extends RouterTypes = any, TPathParams extends object = any, TMethod extends RouteMethod = RouteMethod> = (context: RouteContext<T, TPathParams, TMethod>) => Awaitable<Response | void>;
 declare class RouterTypes<T extends MiddlewareChain = any> extends Function {
     /** This property won't exist at runtime. It contains type information for inference purposes. */
-    $: T['$'];
+    $Router: T['$MiddlewareChain'];
 }
 interface Router<T extends MiddlewareChain = any> extends RouterTypes<T> {
     (context: AdapterRequestContext<Platform<T>>): Awaitable<void | Response>;
@@ -174,7 +188,7 @@ declare const kRequestChain: unique symbol;
 declare const kResponseChain: unique symbol;
 declare class MiddlewareChain<T extends MiddlewareTypes = any> {
     /** This property won't exist at runtime. It contains type information for inference purposes. */
-    $: T;
+    $MiddlewareChain: T;
     /** The number of parameters when called as a function. */
     readonly length: 1;
     protected [kRequestChain]: RequestMiddleware[];
@@ -194,7 +208,7 @@ declare class MiddlewareChain<T extends MiddlewareTypes = any> {
      * Create a middleware function that encapsulates this middleware chain, so
      * any modifications it makes to the request context are not leaked.
      */
-    isolate(): ((ctx: IsolatedContext<this>) => Promise<Response | void>) | typeof noop;
+    isolate(): (ctx: IsolatedContext<this>) => Awaitable<Response | void>;
 }
 declare function chain<TEnv extends object = {}, TProperties extends object = {}, TPlatform = unknown>(): MiddlewareChain<{
     initial: {
@@ -207,6 +221,6 @@ declare function chain<TEnv extends object = {}, TProperties extends object = {}
     };
     platform: TPlatform;
 }>;
-declare function chain<const T extends Middleware = Middleware>(middleware: T): ApplyFirstMiddleware<T>;
+declare function chain<const T extends Middleware = Middleware<{}, {}, unknown>>(middleware: T): ApplyFirstMiddleware<T>;
 
 export { type ApplyMiddleware as A, type EmptyMiddlewareChain as E, type MiddlewareContext as M, type Router as R, MiddlewareChain as a, type RouteContext as b, type RouteHandler 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,4 +1,3 @@
-import 'radashi';
-export { A as ApplyMiddleware, e as ExtractMiddleware, f as Middleware, a as MiddlewareChain, M as MiddlewareContext, g as RequestContext, h as RequestHandler, i as RequestMiddleware, j as RequestPlugin, k as ResponseMiddleware, d as chain } from './index-vRvlpUCy.js';
+export { A as ApplyMiddleware, e as ExtractMiddleware, f as Middleware, a as MiddlewareChain, M as MiddlewareContext, g as RequestContext, h as RequestHandler, i as RequestMiddleware, j as RequestPlugin, k as ResponseMiddleware, d as chain } from './index-B5T_qCSA.js';
 import '@hattip/core';
 import 'pathic';

package/dist/router.d.ts

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

package/package.json

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