@fedify/fedify 2.4.0-pr.936.41 → 2.4.1

package/dist/federation/keycache.test.mjs

@@ -1,11 +1,12 @@
 import { Temporal } from "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { t as MemoryKvStore } from "../kv-CXBAok3k.mjs";
-import { t as assertEquals } from "../assert_equals-BV7oLMxm.mjs";
-import { t as assertInstanceOf } from "../assert_instance_of-Q9KTBnrf.mjs";
-import { t as assert } from "../assert-CJ1KXcvv.mjs";
-import { t as KvKeyCache } from "../keycache-_DHqz5z_.mjs";
+import { t as MemoryKvStore } from "../kv-DCHkaJ9-.mjs";
+import { t as ManualClockKvStore } from "../kv-DBRWVx3Q.mjs";
+import { t as assertEquals } from "../assert_equals-Z6IcEbWU.mjs";
+import { t as assertInstanceOf } from "../assert_instance_of-mrXWWNY-.mjs";
+import { t as assert } from "../assert-D1Eafmd_.mjs";
+import { t as KvKeyCache } from "../keycache-D-MNltOk.mjs";
 import { CryptographicKey, Multikey } from "@fedify/vocab";
 import { test } from "@fedify/fixture";
 //#region src/federation/keycache.test.ts
@@ -13,25 +14,41 @@ test("KvKeyCache.set()", async () => {
 	const kv = new MemoryKvStore();
 	const cache = new KvKeyCache(kv, ["pk"]);
 	await cache.set(new URL("https://example.com/key"), new CryptographicKey({ id: new URL("https://example.com/key") }));
-	assertEquals(await kv.get(["pk", "https://example.com/key"]), {
+	assertEquals(await kv.get([
+		"pk",
+		"2",
+		"https://example.com/key"
+	]), {
 		"@context": "https://w3id.org/security/v1",
 		id: "https://example.com/key",
 		type: "CryptographicKey"
 	});
 	await cache.set(new URL("https://example.com/key2"), new Multikey({ id: new URL("https://example.com/key2") }));
-	assertEquals(await kv.get(["pk", "https://example.com/key2"]), {
+	assertEquals(await kv.get([
+		"pk",
+		"2",
+		"https://example.com/key2"
+	]), {
 		"@context": "https://w3id.org/security/multikey/v1",
 		id: "https://example.com/key2",
 		type: "Multikey"
 	});
 	await cache.set(new URL("https://example.com/null"), null);
 	assert(cache.nullKeys.has("https://example.com/null"));
-	assertEquals(await kv.get(["pk", "https://example.com/null"]), null);
+	assertEquals(await kv.get([
+		"pk",
+		"2",
+		"https://example.com/null"
+	]), null);
 });
 test("KvKeyCache.get()", async () => {
 	const kv = new MemoryKvStore();
 	const cache = new KvKeyCache(kv, ["pk"]);
-	await kv.set(["pk", "https://example.com/key"], {
+	await kv.set([
+		"pk",
+		"2",
+		"https://example.com/key"
+	], {
 		"@context": "https://w3id.org/security/v1",
 		id: "https://example.com/key",
 		type: "CryptographicKey"
@@ -39,7 +56,11 @@ test("KvKeyCache.get()", async () => {
 	const cryptoKey = await cache.get(new URL("https://example.com/key"));
 	assertInstanceOf(cryptoKey, CryptographicKey);
 	assertEquals(cryptoKey?.id?.href, "https://example.com/key");
-	await kv.set(["pk", "https://example.com/key2"], {
+	await kv.set([
+		"pk",
+		"2",
+		"https://example.com/key2"
+	], {
 		"@context": "https://w3id.org/security/multikey/v1",
 		id: "https://example.com/key2",
 		type: "Multikey"
@@ -49,7 +70,11 @@ test("KvKeyCache.get()", async () => {
 	assertEquals(multikey?.id?.href, "https://example.com/key2");
 	cache.nullKeys.set("https://example.com/null", Temporal.Now.instant().add(Temporal.Duration.from({ minutes: 10 })));
 	assertEquals(await cache.get(new URL("https://example.com/null")), null);
-	await kv.set(["pk", "https://example.com/null2"], null);
+	await kv.set([
+		"pk",
+		"2",
+		"https://example.com/null2"
+	], null);
 	assertEquals(await new KvKeyCache(kv, ["pk"]).get(new URL("https://example.com/null2")), null);
 });
 test("KvKeyCache fetch error metadata", async () => {
@@ -78,17 +103,224 @@ test("KvKeyCache fetch error metadata", async () => {
 	await cache.setFetchError(keyId, null);
 	assertEquals(await cache.getFetchError(keyId), void 0);
 });
+test("KvKeyCache reads legacy fetch errors", async () => {
+	const kv = new MemoryKvStore();
+	const keyId = new URL("https://example.com/key");
+	await kv.set([
+		"pk",
+		"__fetchError",
+		keyId.href
+	], {
+		errorName: "FetchError",
+		errorMessage: "Legacy failure"
+	});
+	const result = await new KvKeyCache(kv, ["pk"]).getFetchError(keyId);
+	assert(result != null && "error" in result);
+	assertEquals(result.error.constructor, Error);
+	assertEquals(result.error.name, "FetchError");
+	assertEquals(result.error.message, "Legacy failure");
+	assertEquals(result.error.cause, void 0);
+});
+test("KvKeyCache keeps unknown error types generic", async () => {
+	class CustomError extends Error {}
+	const kv = new MemoryKvStore();
+	const keyId = new URL("https://example.com/key");
+	const error = new CustomError("Custom failure");
+	error.name = "FetchError";
+	await new KvKeyCache(kv, ["pk"]).setFetchError(keyId, { error });
+	const result = await new KvKeyCache(kv, ["pk"]).getFetchError(keyId);
+	assert(result != null && "error" in result);
+	assertEquals(result.error.constructor, Error);
+	assertEquals(result.error.name, "FetchError");
+	assertEquals(result.error.message, "Custom failure");
+});
 test("KvKeyCache unavailable entries expire", async () => {
-	const cache = new KvKeyCache(new MemoryKvStore(), ["pk"], { unavailableKeyTtl: Temporal.Duration.from({ milliseconds: 1 }) });
+	const kv = new ManualClockKvStore();
+	const unavailableKeyTtl = Temporal.Duration.from({ minutes: 10 });
+	const cache = new KvKeyCache(kv, ["pk"], { unavailableKeyTtl });
 	const keyId = new URL("https://example.com/expired");
 	await cache.set(keyId, null);
 	await cache.setFetchError(keyId, {
 		status: 410,
 		response: new Response(null, { status: 410 })
 	});
-	await new Promise((resolve) => setTimeout(resolve, 10));
+	kv.advance({ minutes: 20 });
+	const later = new KvKeyCache(kv, ["pk"], { unavailableKeyTtl });
+	assertEquals(await later.get(keyId), void 0);
+	assertEquals(await later.getFetchError(keyId), void 0);
+});
+test("KvKeyCache.keyTtl defaults to 30 days", () => {
+	assertEquals(new KvKeyCache(new MemoryKvStore(), ["pk"]).keyTtl.total("day"), 30);
+});
+test("KvKeyCache.keyTtl is configurable", () => {
+	assertEquals(new KvKeyCache(new MemoryKvStore(), ["pk"], { keyTtl: Temporal.Duration.from({ days: 7 }) }).keyTtl.total("day"), 7);
+});
+test("KvKeyCache cached keys expire after keyTtl", async () => {
+	const kv = new ManualClockKvStore();
+	const cache = new KvKeyCache(kv, ["pk"], { keyTtl: Temporal.Duration.from({ days: 30 }) });
+	const keyId = new URL("https://example.com/key");
+	await cache.set(keyId, new CryptographicKey({ id: keyId }));
+	assert(await kv.get([
+		"pk",
+		"2",
+		keyId.href
+	]) != null);
+	assertInstanceOf(await cache.get(keyId), CryptographicKey);
+	kv.advance({ days: 31 });
+	assertEquals(await kv.get([
+		"pk",
+		"2",
+		keyId.href
+	]), void 0);
 	assertEquals(await cache.get(keyId), void 0);
-	assertEquals(await cache.getFetchError(keyId), void 0);
+	assertEquals(cache.nullKeys.has(keyId.href), false);
+	await cache.set(keyId, new CryptographicKey({ id: keyId }));
+	const refetched = await cache.get(keyId);
+	assertInstanceOf(refetched, CryptographicKey);
+	assertEquals(refetched.id?.href, keyId.href);
+});
+test("KvKeyCache.get() ignores entries from an earlier generation", async () => {
+	const kv = new MemoryKvStore();
+	const cache = new KvKeyCache(kv, ["pk"]);
+	await kv.set(["pk", "https://example.com/key"], {
+		"@context": "https://w3id.org/security/v1",
+		id: "https://example.com/key",
+		owner: "https://example.com/impersonated",
+		type: "CryptographicKey"
+	});
+	assertEquals(await cache.get(new URL("https://example.com/key")), void 0);
+});
+test("KvKeyCache.compatibleKeyScope() keeps each purpose apart", async () => {
+	const cache = new KvKeyCache(new MemoryKvStore(), ["pk"]);
+	const keyId = new URL("https://gw.example/.well-known/apgateway/did:key:z6Mk/actor#main-key");
+	const http = cache.compatibleKeyScope("httpSignature");
+	await http.set(keyId, new CryptographicKey({ id: keyId }));
+	await cache.compatibleKeyScope("multikey").set(keyId, null);
+	assertInstanceOf(await http.get(keyId), CryptographicKey);
+	assertEquals(await cache.compatibleKeyScope("multikey").get(keyId), null);
+	assertEquals(await cache.compatibleKeyScope("cryptographicKey").get(keyId), void 0);
+	assertEquals(await cache.get(keyId), void 0);
+	await http.delete(keyId);
+	assertEquals(await http.get(keyId), void 0);
+});
+test("KvKeyCache.compatibleKeyScope() entries expire", async () => {
+	const kv = new ManualClockKvStore();
+	let now = Temporal.Instant.fromEpochMilliseconds(0);
+	const scope = new KvKeyCache(kv, ["pk"], {
+		now: () => now,
+		keyTtl: Temporal.Duration.from({ days: 30 }),
+		unavailableKeyTtl: Temporal.Duration.from({ minutes: 10 })
+	}).compatibleKeyScope("httpSignature");
+	const keyId = new URL("https://gw.example/.well-known/apgateway/did:key:z/a");
+	const nullId = new URL("https://gw.example/.well-known/apgateway/did:key:z/b");
+	const expiringId = new URL("https://gw.example/.well-known/apgateway/did:key:z/c");
+	await scope.set(keyId, new CryptographicKey({ id: keyId }));
+	await scope.set(nullId, null);
+	await scope.set(expiringId, new CryptographicKey({ id: expiringId }), { expires: now.add({ minutes: 5 }) });
+	now = now.add({ minutes: 5 });
+	assertInstanceOf(await scope.get(keyId), CryptographicKey);
+	assertEquals(await scope.get(nullId), null);
+	assertEquals(await scope.get(expiringId), void 0);
+	now = now.add({ minutes: 5 });
+	assertEquals(await scope.get(nullId), void 0);
+	now = Temporal.Instant.fromEpochMilliseconds(0).add({ hours: 1 });
+	assertEquals(await scope.get(keyId), void 0);
+	kv.advance({ hours: 1 });
+	assertEquals(await kv.get([
+		"pk",
+		"__compatible",
+		"httpSignature",
+		keyId.href
+	]), void 0);
+});
+test("KvKeyCache.compatibleKeyScope() drops an entry replaced by an expired one", async () => {
+	const kv = new MemoryKvStore();
+	const now = Temporal.Now.instant();
+	const scope = new KvKeyCache(kv, ["pk"], { now: () => now }).compatibleKeyScope("httpSignature");
+	const keyId = new URL("https://gw.example/.well-known/apgateway/did:key:z/a");
+	await scope.set(keyId, new CryptographicKey({ id: keyId }));
+	await scope.set(keyId, new CryptographicKey({ id: keyId }), { expires: now });
+	assertEquals(await scope.get(keyId), void 0);
+});
+test("KvKeyCache.compatibleKeyScope() ignores malformed entries", async () => {
+	const kv = new MemoryKvStore();
+	const cache = new KvKeyCache(kv, ["pk"]);
+	const keyId = new URL("https://gw.example/.well-known/apgateway/did:key:z/a");
+	const entryKey = [
+		"pk",
+		"__compatible",
+		"multikey",
+		keyId.href
+	];
+	await kv.set(entryKey, { key: "garbage" });
+	assertEquals(await cache.compatibleKeyScope("multikey").get(keyId), void 0);
+	assertEquals(await kv.get(entryKey), void 0);
+	const httpEntryKey = [
+		"pk",
+		"__compatible",
+		"httpSignature",
+		keyId.href
+	];
+	await kv.set(httpEntryKey, {
+		key: await new CryptographicKey({ id: keyId }).toJsonLd(),
+		expires: 1e300
+	});
+	assertEquals(await cache.compatibleKeyScope("httpSignature").get(keyId), void 0);
+	assertEquals(await kv.get(httpEntryKey), void 0);
+});
+test("KvKeyCache.compatibleKeyScope() keeps the owners of keys", async () => {
+	const kv = new MemoryKvStore();
+	const now = Temporal.Instant.fromEpochMilliseconds(0);
+	const scope = new KvKeyCache(kv, ["pk"], {
+		now: () => now,
+		keyTtl: Temporal.Duration.from({ minutes: 5 })
+	}).compatibleKeyScope("httpSignature");
+	const keyId = new URL("https://gw.example/.well-known/apgateway/did:key:z/a");
+	const owner = {
+		"@id": "ap://did:key:z/a",
+		"@type": ["urn:example:Actor"]
+	};
+	assertEquals(await scope.set(keyId, new CryptographicKey({ id: keyId }), {
+		expires: now.add({ hours: 1 }),
+		owner
+	}), now.add({ minutes: 5 }));
+	const entry = await scope.getEntry(keyId);
+	assertInstanceOf(entry?.key, CryptographicKey);
+	assertEquals(entry?.owner, owner);
+	assertEquals(entry?.expires, now.add({ minutes: 5 }));
+	const entryKey = [
+		"pk",
+		"__compatible",
+		"httpSignature",
+		keyId.href
+	];
+	await kv.set(entryKey, JSON.parse(JSON.stringify(await kv.get(entryKey))));
+	assertEquals((await scope.getEntry(keyId))?.owner, owner);
+	await kv.set(entryKey, {
+		...await kv.get(entryKey) ?? {},
+		owner: "bogus"
+	});
+	const malformed = await scope.getEntry(keyId);
+	assertInstanceOf(malformed?.key, CryptographicKey);
+	assertEquals(malformed?.owner, void 0);
+	await scope.set(keyId, new CryptographicKey({ id: keyId }), { owner: {
+		...owner,
+		"urn:example:padding": "x".repeat(64 * 1024)
+	} });
+	const oversized = await scope.getEntry(keyId);
+	assertInstanceOf(oversized?.key, CryptographicKey);
+	assertEquals(oversized?.owner, void 0);
+	assertEquals(await scope.set(keyId, null, { owner }), void 0);
+	assertEquals(await kv.get(entryKey), {
+		key: null,
+		expires: 6e5
+	});
+	assertEquals(await scope.getEntry(keyId), null);
+	assertEquals(await scope.set(keyId, new CryptographicKey({ id: keyId }), {
+		expires: now,
+		owner
+	}), void 0);
+	assertEquals(await scope.getEntry(keyId), void 0);
 });
 //#endregion
 export {};

package/dist/federation/kv.test.mjs

@@ -1,9 +1,9 @@
 import { Temporal } from "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { t as MemoryKvStore } from "../kv-CXBAok3k.mjs";
-import { t as assertEquals } from "../assert_equals-BV7oLMxm.mjs";
-import "../std__assert-B2NnY9bq.mjs";
+import { t as MemoryKvStore } from "../kv-DCHkaJ9-.mjs";
+import { t as assertEquals } from "../assert_equals-Z6IcEbWU.mjs";
+import "../std__assert-DvMDRPes.mjs";
 import { test } from "@fedify/fixture";
 //#region src/federation/kv.test.ts
 test("MemoryKvStore", async (t) => {

package/dist/federation/metrics.test.mjs

@@ -1,12 +1,12 @@
 import "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { t as assertEquals } from "../assert_equals-BV7oLMxm.mjs";
-import "../std__assert-B2NnY9bq.mjs";
-import { t as assertRejects } from "../assert_rejects-EgstcQy5.mjs";
-import { _ as recordKeyLookup, a as instrumentDocumentLoader, b as recordWebFingerHandle, c as recordCircuitBreakerStateChange, d as recordCollectionRequest, f as recordCollectionTotalItems, g as recordInboxActivity, h as recordFanoutRecipients, i as getRemoteHost, l as recordCollectionDispatchDuration, m as recordDocumentFetch, p as recordDocumentCache, r as getFederationMetrics, t as classifyFetchError, u as recordCollectionPageItems, v as recordOutboxActivity, x as registerQueueDepthGauge, y as recordOutboxEnqueue } from "../metrics-DMk-nTxI.mjs";
-import { createTestMeterProvider, test } from "@fedify/fixture";
+import { t as assertEquals } from "../assert_equals-Z6IcEbWU.mjs";
+import "../std__assert-DvMDRPes.mjs";
+import { t as assertRejects } from "../assert_rejects-CTptdYck.mjs";
+import { _ as recordKeyLookup, a as instrumentDocumentLoader, b as recordWebFingerHandle, c as recordCircuitBreakerStateChange, d as recordCollectionRequest, f as recordCollectionTotalItems, g as recordInboxActivity, h as recordFanoutRecipients, i as getRemoteHost, l as recordCollectionDispatchDuration, m as recordDocumentFetch, p as recordDocumentCache, r as getFederationMetrics, t as classifyFetchError, u as recordCollectionPageItems, v as recordOutboxActivity, x as registerQueueDepthGauge, y as recordOutboxEnqueue } from "../metrics-CBugc7uM.mjs";
 import { FetchError } from "@fedify/vocab-runtime";
+import { createTestMeterProvider, test } from "@fedify/fixture";
 import { DataPointType, MeterProvider, MetricReader } from "@opentelemetry/sdk-metrics";
 //#region src/federation/metrics.test.ts
 var TestMetricReader = class extends MetricReader {