feat(transform): add re-calculataion of content-length header

TomokiMiyauci · TomokiMiyauci · commit 61886b9b1386 · 2023-03-19T13:44:33.000+09:00
diff --git a/README.md b/README.md
@@ -148,6 +148,30 @@ compressible.
 For example, image media such as `image/jpag` is not compressible because it is
 already compressed.
 
+## Content-Length
+
+If the Response has a `Content-Length` header, compression may cause the actual
+content length to deviate.
+
+In that case, the `Content-Length` is recalculated.
+
+```ts
+import { compression } from "https://deno.land/x/compression_middleware@$VERSION/mod.ts";
+import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
+
+declare const request: Request;
+const middleware = compression();
+
+const response = await middleware(
+  request,
+  () =>
+    new Response("<body>", { headers: { "content-length": "<body:length>" } }),
+);
+
+assertEquals(await response.text(), "<gzip:body>");
+assertEquals(response.headers.get("content-length"), "<gzip:body:length>");
+```
+
 ## Effects
 
 Middleware may make changes to the following elements of the HTTP message.
@@ -156,6 +180,7 @@ Middleware may make changes to the following elements of the HTTP message.
 - HTTP Headers
   - Content-Encoding
   - Vary
+  - [Content-Length](#content-length)
 
 ## Conditions
 
diff --git a/transform.ts b/transform.ts
@@ -8,7 +8,7 @@ import {
   parseMediaType,
   RepresentationHeader,
 } from "./deps.ts";
-import { isNoTransform } from "./utils.ts";
+import { isNoTransform, reCalcContentLength } from "./utils.ts";
 import type { Encoder } from "./types.ts";
 
 /** Response with `Content-Encoding` header. */
@@ -33,7 +33,9 @@ export async function withContentEncoding(
   if (!isCompressible) return response;
 
   const bodyInit = await context.encode(response.body);
-  const newResponse = new Response(bodyInit, response);
+  const newResponse = await reCalcContentLength(
+    new Response(bodyInit, response),
+  );
 
   newResponse.headers.set(
     RepresentationHeader.ContentEncoding,
diff --git a/transform_test.ts b/transform_test.ts
@@ -27,6 +27,30 @@ describe("withContentEncoding", () => {
     );
   });
 
+  it("should re-calculate content length if the response has content-length header", async () => {
+    const encode = spy(() => "abc");
+
+    const initResponse = new Response("abcdef", {
+      headers: { "content-length": "6" },
+    });
+
+    const response = await withContentEncoding(initResponse, {
+      encoding: "xxx",
+      encode,
+    });
+
+    assertSpyCalls(encode, 1);
+    assert(
+      await equalsResponse(
+        response,
+        new Response("abc", {
+          headers: { "content-length": "3", "content-encoding": "xxx" },
+        }),
+        true,
+      ),
+    );
+  });
+
   it("should not apply if the response does not have content-type header", async () => {
     const encode = spy(() => "abc");
 
diff --git a/utils.ts b/utils.ts
@@ -1,5 +1,26 @@
+import { RepresentationHeader } from "./deps.ts";
+
 const ReNoTransform = /(?:^|,)\s*?no-transform\s*?(?:,|$)/;
 
 export function isNoTransform(input: string): boolean {
   return ReNoTransform.test(input);
 }
+
+export async function reCalcContentLength(
+  response: Response,
+): Promise<Response> {
+  if (
+    response.bodyUsed ||
+    !response.headers.has(RepresentationHeader.ContentLength)
+  ) return response;
+
+  const length = await response
+    .clone()
+    .arrayBuffer()
+    .then((buffer) => buffer.byteLength)
+    .then(String);
+
+  response.headers.set(RepresentationHeader.ContentLength, length);
+
+  return response;
+}
diff --git a/utils_test.ts b/utils_test.ts
@@ -1,5 +1,5 @@
-import { isNoTransform } from "./utils.ts";
-import { assert, describe, it } from "./_dev_deps.ts";
+import { isNoTransform, reCalcContentLength } from "./utils.ts";
+import { assert, describe, equalsResponse, it } from "./_dev_deps.ts";
 
 describe("isNoTransform", () => {
   it("should return true", () => {
@@ -28,3 +28,40 @@ describe("isNoTransform", () => {
     });
   });
 });
+
+describe("reCalcContentLength", () => {
+  it("should have new content-length if the response has content-length header", async () => {
+    const response = await reCalcContentLength(
+      new Response("abc", { headers: { "content-length": "100000" } }),
+    );
+
+    assert(
+      equalsResponse(
+        response,
+        new Response("abc", { headers: { "content-length": "3" } }),
+        true,
+      ),
+    );
+  });
+
+  it("should return same response if the response has been read", async () => {
+    const initResponse = new Response("abc", {
+      headers: { "content-length": "100000" },
+    });
+
+    await initResponse.text();
+
+    assert(initResponse.bodyUsed);
+
+    const response = await reCalcContentLength(initResponse);
+
+    assert(initResponse === response);
+  });
+
+  it("should return same response if the response does not have content-length header", async () => {
+    const initResponse = new Response("abc");
+    const response = await reCalcContentLength(initResponse);
+
+    assert(initResponse === response);
+  });
+});
