@fedify/vocab-runtime 2.4.0-dev.2169 → 2.4.0-dev.2193

package/dist/tests/{url-D7qRF-dF.mjs → url-DfS-cvwr.mjs}

@@ -224,10 +224,14 @@ function isGatewayUrl(url) {
 }
 /**
 * Parses and validates an FEP-ef61 gateway base URI.
+* @throws {TypeError} If the URI is malformed, or is not an HTTP(S) base URI
+*                     with no credentials, path, query, or fragment.  In the
+*                     latter case, the message starts with
+*                     `Invalid FEP-ef61 gateway:`.
 */
 function parseGatewayUrl(url) {
 	const parsed = parseIri(url);
-	if (!isGatewayUrl(parsed)) throw new TypeError("FEP-ef61 gateways must be HTTP(S) base URIs with no credentials, path, query, or fragment.");
+	if (!isGatewayUrl(parsed)) throw new TypeError(`Invalid FEP-ef61 gateway: ${url}.  FEP-ef61 gateways must be HTTP(S) base URIs with no credentials, path, query, or fragment.`);
 	return parsed;
 }
 const COMPATIBLE_ID_PATH_PREFIX = "/.well-known/apgateway/";

package/dist/tests/url.test.cjs

@@ -1,4 +1,4 @@
-const require_url = require("./url-gLKqAO1H.cjs");
+const require_url = require("./url-B8xyTwP-.cjs");
 let node_test = require("node:test");
 let node_assert = require("node:assert");
 //#region src/url.test.ts
@@ -240,7 +240,7 @@ let node_assert = require("node:assert");
 		"https://server.example/?x=1",
 		"https://server.example/#fragment"
 	]) {
-		(0, node_assert.throws)(() => require_url.parseGatewayUrl(url), TypeError);
+		(0, node_assert.throws)(() => require_url.parseGatewayUrl(url), (error) => error instanceof TypeError && error.message.startsWith("Invalid FEP-ef61 gateway: "));
 		(0, node_assert.ok)(!require_url.isGatewayUrl(new URL(url)));
 	}
 });

package/dist/tests/url.test.mjs

@@ -1,4 +1,4 @@
-import { _ as validateLookupAddresses, a as formatIri, c as haveSameFe34Origin, d as isValidPublicIPv4Address, f as isValidPublicIPv6Address, g as toCompatibleEf61Id, h as parseJsonLdId, i as expandIPv6Address, l as haveSameIriOrigin, m as parseIri, n as arePortableUrisEqual, o as fromCompatibleEf61Id, p as parseGatewayUrl, r as canonicalizePortableUri, s as getFe34Origin, t as UrlError, u as isGatewayUrl, v as validatePublicUrl } from "./url-D7qRF-dF.mjs";
+import { _ as validateLookupAddresses, a as formatIri, c as haveSameFe34Origin, d as isValidPublicIPv4Address, f as isValidPublicIPv6Address, g as toCompatibleEf61Id, h as parseJsonLdId, i as expandIPv6Address, l as haveSameIriOrigin, m as parseIri, n as arePortableUrisEqual, o as fromCompatibleEf61Id, p as parseGatewayUrl, r as canonicalizePortableUri, s as getFe34Origin, t as UrlError, u as isGatewayUrl, v as validatePublicUrl } from "./url-DfS-cvwr.mjs";
 import { test } from "node:test";
 import { deepStrictEqual, ok, rejects, strictEqual, throws } from "node:assert";
 //#region src/url.test.ts
@@ -240,7 +240,7 @@ test("parseGatewayUrl() accepts only HTTP(S) base URIs", () => {
 		"https://server.example/?x=1",
 		"https://server.example/#fragment"
 	]) {
-		throws(() => parseGatewayUrl(url), TypeError);
+		throws(() => parseGatewayUrl(url), (error) => error instanceof TypeError && error.message.startsWith("Invalid FEP-ef61 gateway: "));
 		ok(!isGatewayUrl(new URL(url)));
 	}
 });

package/dist/{url-BHZYe8Vu.js → url-Be3moMor.js}

@@ -225,10 +225,14 @@ function isGatewayUrl(url) {
 }
 /**
 * Parses and validates an FEP-ef61 gateway base URI.
+* @throws {TypeError} If the URI is malformed, or is not an HTTP(S) base URI
+*                     with no credentials, path, query, or fragment.  In the
+*                     latter case, the message starts with
+*                     `Invalid FEP-ef61 gateway:`.
 */
 function parseGatewayUrl(url) {
 	const parsed = parseIri(url);
-	if (!isGatewayUrl(parsed)) throw new TypeError("FEP-ef61 gateways must be HTTP(S) base URIs with no credentials, path, query, or fragment.");
+	if (!isGatewayUrl(parsed)) throw new TypeError(`Invalid FEP-ef61 gateway: ${url}.  FEP-ef61 gateways must be HTTP(S) base URIs with no credentials, path, query, or fragment.`);
 	return parsed;
 }
 const COMPATIBLE_ID_PATH_PREFIX = "/.well-known/apgateway/";

package/dist/{url-P6l9s9dN.cjs → url-DDVweCXr.cjs}

@@ -227,10 +227,14 @@ function isGatewayUrl(url) {
 }
 /**
 * Parses and validates an FEP-ef61 gateway base URI.
+* @throws {TypeError} If the URI is malformed, or is not an HTTP(S) base URI
+*                     with no credentials, path, query, or fragment.  In the
+*                     latter case, the message starts with
+*                     `Invalid FEP-ef61 gateway:`.
 */
 function parseGatewayUrl(url) {
 	const parsed = parseIri(url);
-	if (!isGatewayUrl(parsed)) throw new TypeError("FEP-ef61 gateways must be HTTP(S) base URIs with no credentials, path, query, or fragment.");
+	if (!isGatewayUrl(parsed)) throw new TypeError(`Invalid FEP-ef61 gateway: ${url}.  FEP-ef61 gateways must be HTTP(S) base URIs with no credentials, path, query, or fragment.`);
 	return parsed;
 }
 const COMPATIBLE_ID_PATH_PREFIX = "/.well-known/apgateway/";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fedify/vocab-runtime",
-  "version": "2.4.0-dev.2169+0a45df07",
+  "version": "2.4.0-dev.2193+402149b5",
   "homepage": "https://fedify.dev/",
   "repository": {
     "type": "git",

package/src/body.ts

@@ -93,3 +93,60 @@ export async function readBoundedText(
     reader?.releaseLock();
   }
 }
+
+/**
+ * Reads raw bytes while limiting bytes received from the body stream.
+ * Unlike {@link readBoundedText}, the bytes are returned as they were
+ * received, without decoding.
+ * @param message The response or request to read.
+ * @param maxBytes The maximum number of decoded bytes to read.
+ * @param url The URL to include in errors and logs.
+ * @returns The body bytes.
+ * @throws {BodyTooLargeError} If the body exceeds the limit.
+ * @internal
+ */
+export async function readBoundedBytes(
+  message: Pick<Request, "body" | "headers">,
+  maxBytes: number,
+  url: string | URL,
+): Promise<Uint8Array<ArrayBuffer>> {
+  validateBodySizeLimit(maxBytes);
+  const reader = message.body?.getReader();
+  const tooLarge = (): never => {
+    getLogger(["fedify", "runtime", "body"]).warn(
+      "Body from {url} exceeds the limit of {maxBytes} bytes.",
+      { url: url.toString(), maxBytes },
+    );
+    throw new BodyTooLargeError(url, maxBytes);
+  };
+  try {
+    const length = message.headers.get("Content-Length");
+    const encoding = message.headers.get("Content-Encoding");
+    if (
+      (encoding == null || encoding.toLowerCase() === "identity") &&
+      length != null && /^\d+$/.test(length) && Number(length) > maxBytes
+    ) tooLarge();
+    if (reader == null) return new Uint8Array(0);
+    const chunks: Uint8Array[] = [];
+    let size = 0;
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      size += value.byteLength;
+      if (size > maxBytes) tooLarge();
+      chunks.push(value);
+    }
+    const bytes = new Uint8Array(size);
+    let offset = 0;
+    for (const chunk of chunks) {
+      bytes.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    return bytes;
+  } catch (error) {
+    if (reader != null) void reader.cancel(error).catch(() => {});
+    throw error;
+  } finally {
+    reader?.releaseLock();
+  }
+}

package/src/docloader.test.ts

@@ -1,13 +1,22 @@
 import { configure, type LogRecord, reset } from "@logtape/logtape";
 import fetchMock from "fetch-mock";
-import { deepStrictEqual, ok, rejects } from "node:assert";
+import { deepStrictEqual, ok, rejects, throws } from "node:assert";
 import dns from "node:dns/promises";
 import { test } from "node:test";
-import { createServer } from "node:http";
+import {
+  createServer,
+  type IncomingMessage,
+  type ServerResponse,
+} from "node:http";
 import { gzipSync } from "node:zlib";
 import preloadedContexts from "./contexts.ts";
 import cidV1Context from "./contexts/cid-v1.json" with { type: "json" };
-import { getDocumentLoader, getRemoteDocument } from "./docloader.ts";
+import {
+  getDocumentLoader,
+  getRemoteDocument,
+  resolveDocumentLoaderTimeout,
+  withDocumentLoaderTimeout,
+} from "./docloader.ts";
 import { FetchError } from "./request.ts";
 import { UrlError } from "./url.ts";
 
@@ -1118,3 +1127,332 @@ test("getDocumentLoader() rejects cancellation before fetching", async () => {
     fetchMock.hardReset();
   }
 });
+
+async function withServer<T>(
+  handler: (request: IncomingMessage, response: ServerResponse) => void,
+  callback: (baseUrl: string) => Promise<T>,
+): Promise<T> {
+  const server = createServer(handler);
+  await new Promise<void>((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", resolve);
+  });
+  try {
+    const address = server.address();
+    ok(address != null && typeof address !== "string");
+    return await callback(`http://127.0.0.1:${address.port}`);
+  } finally {
+    await new Promise<void>((resolve, reject) => {
+      server.close((error) => error == null ? resolve() : reject(error));
+      server.closeAllConnections();
+    });
+  }
+}
+
+function isTimeoutFetchError(error: unknown, url: string): boolean {
+  ok(error instanceof FetchError, String(error));
+  deepStrictEqual(error.url.href, url);
+  deepStrictEqual(error.response, undefined);
+  ok(error.cause instanceof DOMException);
+  deepStrictEqual(error.cause.name, "TimeoutError");
+  return true;
+}
+
+test("resolveDocumentLoaderTimeout() validates timeouts", () => {
+  deepStrictEqual(resolveDocumentLoaderTimeout(undefined), 10_000);
+  deepStrictEqual(resolveDocumentLoaderTimeout(null), null);
+  deepStrictEqual(resolveDocumentLoaderTimeout(1500), 1500);
+  deepStrictEqual(resolveDocumentLoaderTimeout(0.5), 1);
+  deepStrictEqual(resolveDocumentLoaderTimeout(2_147_483_647), 2_147_483_647);
+  for (const invalid of [0, -1, NaN, Infinity, 2_147_483_648]) {
+    throws(() => resolveDocumentLoaderTimeout(invalid), RangeError);
+  }
+  throws(() => getDocumentLoader({ timeout: 0 }), RangeError);
+});
+
+test("getDocumentLoader() times out a request without a response", async () => {
+  await withServer(() => {
+    // Never respond.
+  }, async (baseUrl) => {
+    const url = `${baseUrl}/hang`;
+    const loader = getDocumentLoader({
+      allowPrivateAddress: true,
+      timeout: 100,
+    });
+    await rejects(loader(url), (e) => isTimeoutFetchError(e, url));
+  });
+});
+
+test("getDocumentLoader() times out a stalled response body", async () => {
+  for (const status of [200, 404]) {
+    await withServer((_, response) => {
+      response.writeHead(status, {
+        "Content-Type": "application/activity+json",
+      });
+      response.write('{"id":');
+      // Never finish the body.
+    }, async (baseUrl) => {
+      const url = `${baseUrl}/stalled`;
+      const loader = getDocumentLoader({
+        allowPrivateAddress: true,
+        timeout: 200,
+      });
+      await rejects(loader(url), (e) => isTimeoutFetchError(e, url));
+    });
+  }
+});
+
+test("getDocumentLoader() shares the timeout across redirects", async () => {
+  let requests = 0;
+  await withServer((request, response) => {
+    requests++;
+    const index = Number(request.url?.split("/").at(-1));
+    setTimeout(() => {
+      if (index >= 15) {
+        response.writeHead(200, {
+          "Content-Type": "application/activity+json",
+        });
+        response.end('{"done":true}');
+        return;
+      }
+      response.writeHead(302, { Location: `/redirect/${index + 1}` });
+      response.end();
+    }, 50);
+  }, async (baseUrl) => {
+    const url = `${baseUrl}/redirect/0`;
+    // Each hop is well within the timeout, but the whole chain is not:
+    const loader = getDocumentLoader({
+      allowPrivateAddress: true,
+      timeout: 300,
+    });
+    await rejects(loader(url), (e) => isTimeoutFetchError(e, url));
+    ok(requests < 16, `requests: ${requests}`);
+    // Without a timeout, the chain completes:
+    const unbounded = getDocumentLoader({
+      allowPrivateAddress: true,
+      timeout: null,
+    });
+    deepStrictEqual((await unbounded(url)).document, { done: true });
+  });
+});
+
+test("getDocumentLoader() shares the timeout across alternates", async (t) => {
+  for (const html of [false, true]) {
+    await t.test(html ? "HTML" : "Link header", async () => {
+      await withServer((request, response) => {
+        const index = Number(request.url?.split("/").at(-1));
+        setTimeout(() => {
+          if (index >= 15) {
+            response.writeHead(200, {
+              "Content-Type": "application/activity+json",
+            });
+            response.end('{"done":true}');
+            return;
+          }
+          const next = `/alternate/${index + 1}`;
+          response.writeHead(
+            200,
+            html ? { "Content-Type": "text/html" } : {
+              "Content-Type": "text/plain",
+              Link:
+                `<${next}>; rel="alternate"; type="application/activity+json"`,
+            },
+          );
+          response.end(
+            html
+              ? `<link rel="alternate" type="application/activity+json" href="${next}">`
+              : "not JSON",
+          );
+        }, 50);
+      }, async (baseUrl) => {
+        const url = `${baseUrl}/alternate/0`;
+        const loader = getDocumentLoader({
+          allowPrivateAddress: true,
+          timeout: 300,
+        });
+        await rejects(loader(url), (e) => isTimeoutFetchError(e, url));
+      });
+    });
+  }
+});
+
+test("getDocumentLoader() lets the caller's signal abort a request", async () => {
+  await withServer(() => {
+    // Never respond.
+  }, async (baseUrl) => {
+    const url = `${baseUrl}/hang`;
+    for (const timeout of [undefined, 60_000, null]) {
+      const loader = getDocumentLoader({ allowPrivateAddress: true, timeout });
+      const controller = new AbortController();
+      const reason = new Error("Canceled by the caller");
+      setTimeout(() => controller.abort(reason), 50);
+      await rejects(loader(url, { signal: controller.signal }), (e) => {
+        deepStrictEqual(e, reason);
+        return true;
+      });
+    }
+    // The caller's signal wins even if the timeout fires too:
+    const loader = getDocumentLoader({
+      allowPrivateAddress: true,
+      timeout: 50,
+    });
+    const controller = new AbortController();
+    const reason = new Error("Canceled by the caller");
+    controller.abort(reason);
+    await rejects(loader(url, { signal: controller.signal }), (e) => {
+      deepStrictEqual(e, reason);
+      return true;
+    });
+  });
+});
+
+test("getDocumentLoader() bounds DNS lookups that ignore the timeout", async (t) => {
+  // The validator skips DNS when Deno has no network permission.
+  if (
+    "Deno" in globalThis &&
+    (await Deno.permissions.query({ name: "net" })).state !== "granted"
+  ) {
+    t.skip("requires the net permission");
+    return;
+  }
+  fetchMock.mockGlobal();
+  let requests = 0;
+  const url = "https://slow-dns.example/object";
+  fetchMock.get(url, () => {
+    requests++;
+    return Response.json({ id: url });
+  });
+  // Stubbing works only because url.ts uses the default node:dns/promises
+  // import; see the FIXME there.
+  const originalLookup = dns.lookup;
+  let resolveLookup: () => void = () => {};
+  const lookedUp = new Promise<void>((resolve) => resolveLookup = resolve);
+  dns.lookup = (() =>
+    new Promise((resolve) =>
+      setTimeout(() => {
+        resolve([{ address: "93.184.215.14", family: 4 }]);
+        resolveLookup();
+      }, 200)
+    )) as typeof dns.lookup;
+  try {
+    const loader = getDocumentLoader({ timeout: 50 });
+    await rejects(loader(url), (e) => isTimeoutFetchError(e, url));
+    // A late DNS answer must not start the request anymore:
+    await lookedUp;
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    deepStrictEqual(requests, 0);
+  } finally {
+    dns.lookup = originalLookup;
+    fetchMock.hardReset();
+  }
+});
+
+test("withDocumentLoaderTimeout() cleans up after each call", async () => {
+  const signals: AbortSignal[] = [];
+  const loader = withDocumentLoaderTimeout((url, options) => {
+    signals.push(options!.signal!);
+    return Promise.resolve({
+      contextUrl: null,
+      document: {},
+      documentUrl: url,
+    });
+  }, 50);
+  const results = await Promise.all([
+    loader("https://example.com/a"),
+    loader("https://example.com/b"),
+  ]);
+  deepStrictEqual(results.map((r) => r.documentUrl), [
+    "https://example.com/a",
+    "https://example.com/b",
+  ]);
+  ok(signals[0] !== signals[1]);
+  // The timers are cleared, so the signals are never aborted:
+  await new Promise((resolve) => setTimeout(resolve, 100));
+  ok(signals.every((signal) => !signal.aborted));
+  // A loader that is given no timeout is returned as is:
+  const inner = () => Promise.reject(new Error("unused"));
+  ok(withDocumentLoaderTimeout(inner, null) === inner);
+});
+
+test("getRemoteDocument() keeps error bodies byte for byte", async () => {
+  const bytes = new Uint8Array([0xef, 0xbb, 0xbf, 0x4e, 0x6f, 0xff, 0xfe]);
+  const url = "https://example.com/error";
+  let error: unknown;
+  await rejects(
+    getRemoteDocument(
+      url,
+      new Response(bytes, { status: 404 }),
+      () => Promise.reject(new Error("unused")),
+    ),
+    (e) => {
+      error = e;
+      return true;
+    },
+  );
+  ok(error instanceof FetchError);
+  ok(error.response != null);
+  deepStrictEqual(error.response.status, 404);
+  deepStrictEqual(new Uint8Array(await error.response.arrayBuffer()), bytes);
+});
+
+test("getRemoteDocument() keeps metadata of bodiless or large errors", async () => {
+  const url = "https://example.com/error";
+  for (
+    const response of [
+      new Response(null, { status: 304, headers: { ETag: '"a"' } }),
+      new Response(new Uint8Array(1024 * 1024 + 1), {
+        status: 500,
+        headers: { ETag: '"a"' },
+      }),
+    ]
+  ) {
+    await rejects(
+      getRemoteDocument(
+        url,
+        response,
+        () => Promise.reject(new Error("unused")),
+      ),
+      (e) => {
+        ok(e instanceof FetchError);
+        ok(e.response != null);
+        deepStrictEqual(e.response.status, response.status);
+        deepStrictEqual(e.response.headers.get("ETag"), '"a"');
+        deepStrictEqual(e.response.body, null);
+        return true;
+      },
+    );
+  }
+});
+
+test("getDocumentLoader() reports statuses that Response cannot hold", async () => {
+  await withServer((_, response) => {
+    response.writeHead(999);
+    response.end("Request denied");
+  }, async (baseUrl) => {
+    const url = `${baseUrl}/denied`;
+    const loader = getDocumentLoader({ allowPrivateAddress: true });
+    let error: unknown;
+    await rejects(loader(url), (e) => {
+      error = e;
+      return true;
+    });
+    ok(error instanceof FetchError, String(error));
+    deepStrictEqual(error.response?.status, 999);
+    deepStrictEqual(await error.response.text(), "Request denied");
+  });
+});
+
+test("getDocumentLoader() times out a stalled body of such a status", async () => {
+  await withServer((_, response) => {
+    response.writeHead(999);
+    response.write("Request");
+    // Never finish the body.
+  }, async (baseUrl) => {
+    const url = `${baseUrl}/stalled-denied`;
+    const loader = getDocumentLoader({
+      allowPrivateAddress: true,
+      timeout: 200,
+    });
+    await rejects(loader(url), (e) => isTimeoutFetchError(e, url));
+  });
+});