Use customisable filter

packages/http-client/src/Filter.ts

@@ -1,24 +1,26 @@
-import { ImmutableResponse } from "~/src/ImmutableResponse.js";
-import { ImmutableRequest } from "~/src/ImmutableRequest.js";
+import { ImmutableRequest } from "~/src/ImmutableRequest";
+import { Task } from "@ollierelph/result4t";
 
-type FilterApply = (next: HttpHandler) => HttpHandler;
+export type HttpHandler<Return> = (request: ImmutableRequest) => Return;
 
-export type HttpHandler = (
-  request: ImmutableRequest,
-) => Promise<ImmutableResponse>;
-
-export class Filter {
-  protected constructor(protected base: FilterApply) {}
-
-  static from(base: FilterApply) {
-    return new Filter(base);
+export class Filter<HttpHandlerSignature extends HttpHandler<unknown>> {
+  #task: Task<[input: HttpHandlerSignature], HttpHandlerSignature>;
+  protected constructor(
+    fn: (next: HttpHandlerSignature) => HttpHandlerSignature,
+  ) {
+    this.#task = Task.of(fn);
   }
-
-  then(filter: Filter): Filter {
-    return new Filter((other) => this.base(filter.base(other)));
+  static from<HttpHandlerSignature extends HttpHandler<unknown>>(
+    fn: (next: HttpHandlerSignature) => HttpHandlerSignature,
+  ) {
+    return new Filter<HttpHandlerSignature>(fn);
   }
-
-  apply(filter: HttpHandler): HttpHandler {
-    return this.base(filter);
+  then<Other extends Filter<HttpHandlerSignature>>(otherFilter: Other) {
+    return new Filter((next: HttpHandlerSignature) =>
+      this.#task.call(otherFilter.apply(next)),
+    );
+  }
+  apply(filter: HttpHandlerSignature): HttpHandlerSignature {
+    return this.#task.call(filter);
   }
 }

packages/http-client/test/Filter.ts

@@ -6,18 +6,24 @@ import { Filter, HttpHandler } from "~/src/Filter";
 import { ImmutableURL } from "~/src/ImmutableURL";
 
 const setHostnameForEnvironment = (env: string) =>
-  Filter.from((next) => async (request: ImmutableRequest) => {
-    const finalUrl = request.url.copy({ hostname: `${env}.example.com` });
-    return next(request.copy({ url: finalUrl }));
-  });
+  Filter.from(
+    (next: HttpHandler<Promise<ImmutableResponse>>) =>
+      async (request: ImmutableRequest) => {
+        const finalUrl = request.url.copy({ hostname: `${env}.example.com` });
+        return next(request.copy({ url: finalUrl }));
+      },
+  );
 
-const addAuth = Filter.from((next) => async (request: ImmutableRequest) => {
-  const finalHeaders = request.headers.append("Authorization", "Basic 123");
-  return next(request.copy({ headers: finalHeaders }));
-});
+const addAuth = Filter.from(
+  (next: HttpHandler<Promise<ImmutableResponse>>) =>
+    async (request: ImmutableRequest) => {
+      const finalHeaders = request.headers.append("Authorization", "Basic 123");
+      return next(request.copy({ headers: finalHeaders }));
+    },
+);
 
 const alwaysStatusAndReflectRequest =
-  (status: StatusCode): HttpHandler =>
+  (status: StatusCode): HttpHandler<Promise<ImmutableResponse>> =>
   async (req) =>
     ImmutableResponse.of(null, {
       status,