feat(middleware): filter conditional headers if selecting representation

Author: TomokiMiyauci

README.md

@@ -21,7 +21,8 @@ For a definition of Universal HTTP middleware, see the
 
 ## Usage
 
-To evaluate precondition, you need to provide a function to retrieve the
+To evaluate precondition, you need to provide
+[select representation](#select-representation) function to retrieve the
 [selected representation](https://www.rfc-editor.org/rfc/rfc9110#selected.representation).
 
 The following example evaluates the `If-None-Match` precondition and handle
@@ -56,6 +57,32 @@ assertEquals(response.status, 304);
 assertFalse(response.body);
 ```
 
+## Select representation
+
+The evaluation of the pre-conditions is always done on the selected
+representation.
+
+You must provide a function to retrieve the representation.
+
+Select representation is the following interface:
+
+```ts
+interface SelectRepresentation {
+  (request: Request): Response | Promise<Response>;
+}
+```
+
+The select representation is executed prior to the handler when a request with a
+precondition header is received.
+
+The select representation removes the pre-conditional header from the actual
+request header in order to satisfy the following requirement.
+
+> A server MUST ignore all received preconditions if its response to the same
+> request without those conditions, prior to processing the request content,
+> would have been a status code other than a 2xx (Successful) or 412
+> (Precondition Failed).
+
 ## Precondition
 
 [RFC 9110, 13.1. Preconditions](https://www.rfc-editor.org/rfc/rfc9110#section-13.1)

_dev_deps.ts

@@ -12,6 +12,7 @@ export {
   spy,
 } from "https://deno.land/[email protected]/testing/mock.ts";
 export { equalsResponse } from "https://deno.land/x/[email protected]/response.ts";
+export { equalsRequest } from "https://deno.land/x/[email protected]/request.ts";
 export {
   ConditionalHeader,
   RangeHeader,

deps.ts

@@ -6,6 +6,7 @@ export {
   Status,
   type SuccessfulStatus,
 } from "https://deno.land/[email protected]/http/http_status.ts";
+export { distinct } from "https://deno.land/[email protected]/collections/distinct.ts";
 export {
   isBoolean,
   isNegativeNumber,
@@ -21,6 +22,7 @@ export {
 export {
   ConditionalHeader,
   filterKeys,
+  isConditionalHeader,
   isRepresentationHeader,
   RangeHeader,
   RepresentationHeader,
@@ -36,11 +38,11 @@ export {
 } from "https://deno.land/x/[email protected]/mod.ts";
 export { isErr, unsafe } from "https://deno.land/x/[email protected]/mod.ts";
 export { ascend } from "https://deno.land/[email protected]/collections/_comparators.ts";
-export { withContentRange } from "https://deno.land/x/[email protected]-beta.1/transform.ts";
+export { withContentRange } from "https://deno.land/x/[email protected]/transform.ts";
 export {
   BytesRange,
   type Range,
-} from "https://deno.land/x/[email protected]-beta.1/mod.ts";
+} from "https://deno.land/x/[email protected]/mod.ts";
 export { default as parseHttpDate } from "https://esm.sh/[email protected]";
 
 export function not<T extends readonly unknown[]>(

middleware.ts

@@ -8,6 +8,7 @@ import {
   ascendPrecondition,
   isNotSelectionOrModificationMethod,
   isPreEvaluableStatus,
+  withoutConditionHeaders,
 } from "./utils.ts";
 import { IfNoneMatch } from "./preconditions/if_none_match.ts";
 import { IfMatch } from "./preconditions/if_match.ts";
@@ -62,8 +63,9 @@ export function conditionalRequest(
       ],
   ).sort(ascendPrecondition);
 
-  return (request, next) =>
-    _handler(selectRepresentation, preconditions, request, next);
+  const curried = _handler.bind(null, selectRepresentation, preconditions);
+
+  return curried;
 }
 
 /** Handle preconditions with all contexts.
@@ -88,7 +90,14 @@ export async function _handler(
 
   if (!targetPreconditions.length) return next(request);
 
-  const selectedRepresentation = await selectRepresentation(request);
+  const headers = withoutConditionHeaders(
+    request.headers,
+    preconditions.map(({ field }) => field),
+  );
+
+  const selectedRepresentation = await selectRepresentation(
+    new Request(request, { headers }),
+  );
 
   /** A server MUST ignore all received preconditions if its response to the same request without those conditions, prior to processing the request content, would have been a status code other than a 2xx (Successful) or 412 (Precondition Failed).
    */

middleware_test.ts

@@ -4,6 +4,7 @@ import {
   assertSpyCalls,
   ConditionalHeader,
   describe,
+  equalsRequest,
   equalsResponse,
   it,
   Method,
@@ -56,8 +57,12 @@ describe("_handler", () => {
   });
 
   it("should call next handler if the selected response has not pre-evaluable status", async () => {
-    const request = new Request("test:", { headers: { "test": "" } });
-    const select = spy(() => new Response(null, { status: Status.NotFound }));
+    const initRequest = new Request("test:", { headers: { "test": "" } });
+    const select = spy(async (request: Request) => {
+      assert(await equalsRequest(request, new Request("test:")));
+
+      return new Response(null, { status: Status.NotFound });
+    });
     const initResponse = new Response();
     const next = spy(() => initResponse);
     const evaluate = spy(() => true);
@@ -66,14 +71,60 @@ describe("_handler", () => {
     const response = await _handler(
       select,
       [{ field: "test", evaluate, respond }],
-      request,
+      initRequest,
       next,
     );
 
     assertSpyCalls(evaluate, 0);
     assertSpyCalls(respond, 0);
     assertSpyCalls(select, 1);
-    assertSpyCallArg(select, 0, 0, request);
+    assertSpyCalls(next, 1);
+    assert(initResponse === response);
+  });
+
+  it("should request what does not include precondition headers and custom precondition headers", async () => {
+    const initRequest = new Request("test:", {
+      headers: {
+        [ConditionalHeader.IfNoneMatch]: "",
+        [ConditionalHeader.IfMatch]: "",
+        [ConditionalHeader.IfModifiedSince]: "",
+        [ConditionalHeader.IfRange]: "",
+        [ConditionalHeader.IfUnmodifiedSince]: "",
+        "x-precondition": "",
+        "x-test": "",
+      },
+    });
+    const select = spy(async (request: Request) => {
+      assert(
+        await equalsRequest(
+          request,
+          new Request("test:", {
+            headers: {
+              "x-test": "",
+            },
+          }),
+        ),
+      );
+
+      return new Response(null, { status: Status.NotFound });
+    });
+    const initResponse = new Response();
+    const next = spy(() => initResponse);
+    const evaluate = spy(() => true);
+    const respond = spy(() => {});
+
+    const response = await _handler(
+      select,
+      [{ field: ConditionalHeader.IfNoneMatch, evaluate, respond }, {
+        field: "X-Precondition",
+        evaluate,
+        respond,
+      }],
+      initRequest,
+      next,
+    );
+
+    assertSpyCalls(select, 1);
     assertSpyCalls(next, 1);
     assert(initResponse === response);
   });

utils.ts

@@ -3,11 +3,15 @@
 
 import {
   ascend,
+  distinct,
+  filterKeys,
   isBoolean,
+  isConditionalHeader,
   isNegativeNumber,
   isNull,
   isSuccessfulStatus,
   Method,
+  not,
   RepresentationHeader,
   Status,
   SuccessfulStatus,
@@ -89,3 +93,21 @@ export function isBannedHeader(fieldName: string): boolean {
     RepresentationHeader.ContentType,
   ] as string[]).includes(fieldName);
 }
+
+/** Return no precondition header. */
+export function withoutConditionHeaders(
+  headers: Headers,
+  additionalConditionHeaders: readonly string[] = [],
+): Headers {
+  additionalConditionHeaders = distinct(additionalConditionHeaders)
+    .map((v) => v.toLowerCase());
+
+  function isBannedHeader(key: string): boolean {
+    return isConditionalHeader(key) ||
+      additionalConditionHeaders.includes(key);
+  }
+
+  const newHeaders = filterKeys(headers, not(isBannedHeader));
+
+  return newHeaders;
+}

utils_test.ts

@@ -3,6 +3,7 @@ import {
   ascendPreconditionHeader,
   type Ord,
   toPriority,
+  withoutConditionHeaders,
 } from "./utils.ts";
 import {
   assert,
@@ -150,3 +151,41 @@ describe("applyPrecondition", () => {
     assert(newResponse === result);
   });
 });
+
+describe("withoutConditionHeaders", () => {
+  it("should return headers what does not include precondition header", () => {
+    assertEquals(withoutConditionHeaders(new Headers()), new Headers());
+    assertEquals(
+      withoutConditionHeaders(
+        new Headers({
+          [ConditionalHeader.IfMatch]: "",
+          [ConditionalHeader.IfModifiedSince]: "",
+          [ConditionalHeader.IfNoneMatch]: "",
+          [ConditionalHeader.IfRange]: "",
+          [ConditionalHeader.IfUnmodifiedSince]: "",
+          "x-x": "",
+        }),
+      ),
+      new Headers({ "x-x": "" }),
+    );
+  });
+
+  it("should add additional conditional headers", () => {
+    assertEquals(
+      withoutConditionHeaders(
+        new Headers({
+          [ConditionalHeader.IfMatch]: "",
+          [ConditionalHeader.IfModifiedSince]: "",
+          [ConditionalHeader.IfNoneMatch]: "",
+          [ConditionalHeader.IfRange]: "",
+          [ConditionalHeader.IfUnmodifiedSince]: "",
+          "x-x": "",
+          "x-test": "",
+          "x-precondition": "",
+        }),
+        ["x-precondition", "x-test", ConditionalHeader.IfMatch],
+      ),
+      new Headers({ "x-x": "" }),
+    );
+  });
+});