@fedify/fedify 1.6.0-dev.814 → 1.6.0

package/dist/federation/inbox.js

@@ -0,0 +1,165 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { deno_default } from "../deno.js";
+import { getTypeId } from "../vocab/type.js";
+import { Activity } from "../vocab/vocab.js";
+import { getLogger } from "@logtape/logtape";
+import { SpanKind, SpanStatusCode, context, propagation, trace } from "@opentelemetry/api";
+
+//#region federation/inbox.ts
+var InboxListenerSet = class {
+	#listeners;
+	constructor() {
+		this.#listeners = new Map();
+	}
+	add(type, listener) {
+		if (this.#listeners.has(type)) throw new TypeError("Listener already set for this type.");
+		this.#listeners.set(type, listener);
+	}
+	dispatchWithClass(activity) {
+		let cls = activity.constructor;
+		const inboxListeners = this.#listeners;
+		if (inboxListeners == null) return null;
+		while (true) {
+			if (inboxListeners.has(cls)) break;
+			if (cls === Activity) return null;
+			cls = globalThis.Object.getPrototypeOf(cls);
+		}
+		const listener = inboxListeners.get(cls);
+		return {
+			class: cls,
+			listener
+		};
+	}
+	dispatch(activity) {
+		return this.dispatchWithClass(activity)?.listener ?? null;
+	}
+};
+async function routeActivity({ context: ctx, json, activity, recipient, inboxListeners, inboxContextFactory, inboxErrorHandler, kv, kvPrefixes, queue, span, tracerProvider }) {
+	const logger = getLogger([
+		"fedify",
+		"federation",
+		"inbox"
+	]);
+	const cacheKey = activity.id == null ? null : [
+		...kvPrefixes.activityIdempotence,
+		ctx.origin,
+		activity.id.href
+	];
+	if (cacheKey != null) {
+		const cached = await kv.get(cacheKey);
+		if (cached === true) {
+			logger.debug("Activity {activityId} has already been processed.", {
+				activityId: activity.id?.href,
+				activity: json,
+				recipient
+			});
+			span.setStatus({
+				code: SpanStatusCode.UNSET,
+				message: `Activity ${activity.id?.href} has already been processed.`
+			});
+			return "alreadyProcessed";
+		}
+	}
+	if (activity.actorId == null) {
+		logger.error("Missing actor.", { activity: json });
+		span.setStatus({
+			code: SpanStatusCode.ERROR,
+			message: "Missing actor."
+		});
+		return "missingActor";
+	}
+	span.setAttribute("activitypub.actor.id", activity.actorId.href);
+	if (queue != null) {
+		const carrier = {};
+		propagation.inject(context.active(), carrier);
+		try {
+			await queue.enqueue({
+				type: "inbox",
+				id: crypto.randomUUID(),
+				baseUrl: ctx.origin,
+				activity: json,
+				identifier: recipient,
+				attempt: 0,
+				started: new Date().toISOString(),
+				traceContext: carrier
+			});
+		} catch (error) {
+			logger.error("Failed to enqueue the incoming activity {activityId}:\n{error}", {
+				error,
+				activityId: activity.id?.href,
+				activity: json,
+				recipient
+			});
+			span.setStatus({
+				code: SpanStatusCode.ERROR,
+				message: `Failed to enqueue the incoming activity ${activity.id?.href}.`
+			});
+			throw error;
+		}
+		logger.info("Activity {activityId} is enqueued.", {
+			activityId: activity.id?.href,
+			activity: json,
+			recipient
+		});
+		return "enqueued";
+	}
+	tracerProvider = tracerProvider ?? trace.getTracerProvider();
+	const tracer = tracerProvider.getTracer(deno_default.name, deno_default.version);
+	return await tracer.startActiveSpan("activitypub.dispatch_inbox_listener", { kind: SpanKind.INTERNAL }, async (span$1) => {
+		const dispatched = inboxListeners?.dispatchWithClass(activity);
+		if (dispatched == null) {
+			logger.error("Unsupported activity type:\n{activity}", {
+				activity: json,
+				recipient
+			});
+			span$1.setStatus({
+				code: SpanStatusCode.UNSET,
+				message: `Unsupported activity type: ${getTypeId(activity).href}`
+			});
+			span$1.end();
+			return "unsupportedActivity";
+		}
+		const { class: cls, listener } = dispatched;
+		span$1.updateName(`activitypub.dispatch_inbox_listener ${cls.name}`);
+		try {
+			await listener(inboxContextFactory(recipient, json, activity?.id?.href, getTypeId(activity).href), activity);
+		} catch (error) {
+			try {
+				await inboxErrorHandler?.(ctx, error);
+			} catch (error$1) {
+				logger.error("An unexpected error occurred in inbox error handler:\n{error}", {
+					error: error$1,
+					activityId: activity.id?.href,
+					activity: json,
+					recipient
+				});
+			}
+			logger.error("Failed to process the incoming activity {activityId}:\n{error}", {
+				error,
+				activityId: activity.id?.href,
+				activity: json,
+				recipient
+			});
+			span$1.setStatus({
+				code: SpanStatusCode.ERROR,
+				message: String(error)
+			});
+			span$1.end();
+			return "error";
+		}
+		if (cacheKey != null) await kv.set(cacheKey, true, { ttl: Temporal.Duration.from({ days: 1 }) });
+		logger.info("Activity {activityId} has been processed.", {
+			activityId: activity.id?.href,
+			activity: json,
+			recipient
+		});
+		span$1.end();
+		return "success";
+	});
+}
+
+//#endregion
+export { InboxListenerSet, routeActivity };

package/dist/federation/inbox.test.d.ts

@@ -0,0 +1,2 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { URLPattern } from "urlpattern-polyfill";

package/dist/federation/inbox.test.js

@@ -0,0 +1,88 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { Activity, Create, Invite, Offer, Update } from "../vocab/vocab.js";
+import { InboxListenerSet } from "./inbox.js";
+import { assertEquals } from "../node_modules/.pnpm/@jsr_std__assert@0.226.0/node_modules/@jsr/std__assert/assert_equals.js";
+import { test } from "../testing/mod.js";
+import { assertThrows } from "../node_modules/.pnpm/@jsr_std__assert@0.226.0/node_modules/@jsr/std__assert/assert_throws.js";
+
+//#region federation/inbox.test.ts
+test("InboxListenerSet", () => {
+	const listeners = new InboxListenerSet();
+	const activity = new Activity({});
+	const offer = new Offer({});
+	const invite = new Invite({});
+	const create = new Create({});
+	const update = new Update({});
+	assertEquals(listeners.dispatch(activity), null);
+	assertEquals(listeners.dispatch(offer), null);
+	assertEquals(listeners.dispatch(invite), null);
+	assertEquals(listeners.dispatch(create), null);
+	assertEquals(listeners.dispatch(update), null);
+	const listenOffer = () => {};
+	listeners.add(Offer, listenOffer);
+	assertEquals(listeners.dispatch(activity), null);
+	assertEquals(listeners.dispatchWithClass(offer), {
+		class: Offer,
+		listener: listenOffer
+	});
+	assertEquals(listeners.dispatch(offer), listenOffer);
+	assertEquals(listeners.dispatchWithClass(invite), {
+		class: Offer,
+		listener: listenOffer
+	});
+	assertEquals(listeners.dispatch(invite), listenOffer);
+	assertEquals(listeners.dispatch(create), null);
+	assertEquals(listeners.dispatch(update), null);
+	const listenCreate = () => {};
+	listeners.add(Create, listenCreate);
+	assertEquals(listeners.dispatch(activity), null);
+	assertEquals(listeners.dispatch(offer), listenOffer);
+	assertEquals(listeners.dispatchWithClass(offer), {
+		class: Offer,
+		listener: listenOffer
+	});
+	assertEquals(listeners.dispatch(invite), listenOffer);
+	assertEquals(listeners.dispatchWithClass(invite), {
+		class: Offer,
+		listener: listenOffer
+	});
+	assertEquals(listeners.dispatch(create), listenCreate);
+	assertEquals(listeners.dispatchWithClass(create), {
+		class: Create,
+		listener: listenCreate
+	});
+	assertEquals(listeners.dispatch(update), null);
+	const listenActivity = () => {};
+	listeners.add(Activity, listenActivity);
+	assertEquals(listeners.dispatch(activity), listenActivity);
+	assertEquals(listeners.dispatchWithClass(activity), {
+		class: Activity,
+		listener: listenActivity
+	});
+	assertEquals(listeners.dispatch(offer), listenOffer);
+	assertEquals(listeners.dispatchWithClass(offer), {
+		class: Offer,
+		listener: listenOffer
+	});
+	assertEquals(listeners.dispatch(invite), listenOffer);
+	assertEquals(listeners.dispatchWithClass(invite), {
+		class: Offer,
+		listener: listenOffer
+	});
+	assertEquals(listeners.dispatch(create), listenCreate);
+	assertEquals(listeners.dispatchWithClass(create), {
+		class: Create,
+		listener: listenCreate
+	});
+	assertEquals(listeners.dispatch(update), listenActivity);
+	assertEquals(listeners.dispatchWithClass(update), {
+		class: Activity,
+		listener: listenActivity
+	});
+	assertThrows(() => listeners.add(Activity, listenActivity), TypeError, "Listener already set for this type.");
+});
+
+//#endregion

package/dist/federation/keycache.js

@@ -0,0 +1,47 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { CryptographicKey, Multikey } from "../vocab/vocab.js";
+
+//#region federation/keycache.ts
+var KvKeyCache = class {
+	kv;
+	prefix;
+	options;
+	nullKeys;
+	constructor(kv, prefix, options = {}) {
+		this.kv = kv;
+		this.prefix = prefix;
+		this.nullKeys = new Set();
+		this.options = options;
+	}
+	async get(keyId) {
+		if (this.nullKeys.has(keyId.href)) return null;
+		const serialized = await this.kv.get([...this.prefix, keyId.href]);
+		if (serialized == null) return void 0;
+		try {
+			return await CryptographicKey.fromJsonLd(serialized, this.options);
+		} catch {
+			try {
+				return await Multikey.fromJsonLd(serialized, this.options);
+			} catch {
+				await this.kv.delete([...this.prefix, keyId.href]);
+				return void 0;
+			}
+		}
+	}
+	async set(keyId, key) {
+		if (key == null) {
+			this.nullKeys.add(keyId.href);
+			await this.kv.delete([...this.prefix, keyId.href]);
+			return;
+		}
+		this.nullKeys.delete(keyId.href);
+		const serialized = await key.toJsonLd(this.options);
+		await this.kv.set([...this.prefix, keyId.href], serialized);
+	}
+};
+
+//#endregion
+export { KvKeyCache };

package/dist/federation/keycache.test.d.ts

@@ -0,0 +1,2 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { URLPattern } from "urlpattern-polyfill";

package/dist/federation/keycache.test.js

@@ -0,0 +1,55 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { CryptographicKey, Multikey } from "../vocab/vocab.js";
+import { KvKeyCache } from "./keycache.js";
+import { MemoryKvStore } from "./kv.js";
+import { assert } from "../node_modules/.pnpm/@jsr_std__assert@0.226.0/node_modules/@jsr/std__assert/assert.js";
+import { assertEquals } from "../node_modules/.pnpm/@jsr_std__assert@0.226.0/node_modules/@jsr/std__assert/assert_equals.js";
+import { assertInstanceOf } from "../node_modules/.pnpm/@jsr_std__assert@0.226.0/node_modules/@jsr/std__assert/assert_instance_of.js";
+import { test } from "../testing/mod.js";
+
+//#region federation/keycache.test.ts
+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"]), {
+		"@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"]), {
+		"@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"));
+});
+test("KvKeyCache.get()", 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",
+		type: "CryptographicKey"
+	});
+	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"], {
+		"@context": "https://w3id.org/security/multikey/v1",
+		id: "https://example.com/key2",
+		type: "Multikey"
+	});
+	const multikey = await cache.get(new URL("https://example.com/key2"));
+	assertInstanceOf(multikey, Multikey);
+	assertEquals(multikey?.id?.href, "https://example.com/key2");
+	cache.nullKeys.add("https://example.com/null");
+	assertEquals(await cache.get(new URL("https://example.com/null")), null);
+});
+
+//#endregion

package/dist/federation/kv.d.ts

@@ -0,0 +1,74 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { URLPattern } from "urlpattern-polyfill";
+
+//#region federation/kv.d.ts
+/**
+* A key for a key-value store.  An array of one or more strings.
+*
+* @since 0.5.0
+*/
+/**
+ * A key for a key-value store.  An array of one or more strings.
+ *
+ * @since 0.5.0
+ */
+type KvKey = readonly [string] | readonly [string, ...string[]];
+/**
+ * Additional options for setting a value in a key-value store.
+ *
+ * @since 0.5.0
+ */
+interface KvStoreSetOptions {
+  /**
+   * The time-to-live (TTL) for the value.
+   */
+  ttl?: Temporal.Duration;
+}
+/**
+ * An abstract interface for a key-value store.
+ *
+ * @since 0.5.0
+ */
+interface KvStore {
+  /**
+   * Gets the value for the given key.
+   * @param key The key to get the value for.
+   * @returns The value for the key, or `undefined` if the key does not exist.
+   * @typeParam T The type of the value to get.
+   */
+  get<T = unknown>(key: KvKey): Promise<T | undefined>;
+  /**
+   * Sets the value for the given key.
+   * @param key The key to set the value for.
+   * @param value The value to set.
+   * @param options Additional options for setting the value.
+   */
+  set(key: KvKey, value: unknown, options?: KvStoreSetOptions): Promise<void>;
+  /**
+   * Deletes the value for the given key.
+   * @param key The key to delete.
+   */
+  delete(key: KvKey): Promise<void>;
+}
+/**
+ * A key-value store that stores values in memory.
+ * Do not use this in production as it does not persist values.
+ *
+ * @since 0.5.0
+ */
+declare class MemoryKvStore implements KvStore {
+  #private;
+  /**
+   * {@inheritDoc KvStore.get}
+   */
+  get<T = unknown>(key: KvKey): Promise<T | undefined>;
+  /**
+   * {@inheritDoc KvStore.set}
+   */
+  set(key: KvKey, value: unknown, options?: KvStoreSetOptions): Promise<void>;
+  /**
+   * {@inheritDoc KvStore.delete}
+   */
+  delete(key: KvKey): Promise<void>;
+} //#endregion
+export { KvKey, KvStore, KvStoreSetOptions, MemoryKvStore as MemoryKvStore$1 };

package/dist/federation/kv.js

@@ -0,0 +1,51 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+//#region federation/kv.ts
+/**
+* A key-value store that stores values in memory.
+* Do not use this in production as it does not persist values.
+*
+* @since 0.5.0
+*/
+var MemoryKvStore = class {
+	#values = {};
+	#encodeKey(key) {
+		return JSON.stringify(key);
+	}
+	/**
+	* {@inheritDoc KvStore.get}
+	*/
+	get(key) {
+		const encodedKey = this.#encodeKey(key);
+		const entry = this.#values[encodedKey];
+		if (entry == null) return Promise.resolve(void 0);
+		const [value, expiration] = entry;
+		if (expiration != null && Temporal.Now.instant().until(expiration).sign < 0) {
+			delete this.#values[encodedKey];
+			return Promise.resolve(void 0);
+		}
+		return Promise.resolve(value);
+	}
+	/**
+	* {@inheritDoc KvStore.set}
+	*/
+	set(key, value, options) {
+		const encodedKey = this.#encodeKey(key);
+		const expiration = options?.ttl == null ? null : Temporal.Now.instant().add(options.ttl.round({ largestUnit: "hour" }));
+		this.#values[encodedKey] = [value, expiration];
+		return Promise.resolve();
+	}
+	/**
+	* {@inheritDoc KvStore.delete}
+	*/
+	delete(key) {
+		const encodedKey = this.#encodeKey(key);
+		delete this.#values[encodedKey];
+		return Promise.resolve();
+	}
+};
+
+//#endregion
+export { MemoryKvStore };

package/dist/federation/kv.test.d.ts

@@ -0,0 +1,2 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { URLPattern } from "urlpattern-polyfill";

package/dist/federation/kv.test.js

@@ -0,0 +1,25 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { MemoryKvStore } from "./kv.js";
+import { assertEquals } from "../node_modules/.pnpm/@jsr_std__assert@0.226.0/node_modules/@jsr/std__assert/assert_equals.js";
+import { test } from "../testing/mod.js";
+
+//#region federation/kv.test.ts
+test("MemoryKvStore", async (t) => {
+	const store = new MemoryKvStore();
+	await t.step("set() & get()", async () => {
+		await store.set(["foo", "bar"], "foobar");
+		assertEquals(await store.get(["foo", "bar"]), "foobar");
+		assertEquals(await store.get(["foo"]), void 0);
+		await store.set(["foo", "baz"], "baz", { ttl: Temporal.Duration.from({ seconds: 0 }) });
+		assertEquals(await store.get(["foo", "baz"]), void 0);
+	});
+	await t.step("delete()", async () => {
+		await store.delete(["foo", "bar"]);
+		assertEquals(await store.get(["foo", "bar"]), void 0);
+	});
+});
+
+//#endregion

package/dist/federation/middleware.d.ts

@@ -0,0 +1,101 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { URLPattern } from "urlpattern-polyfill";
+import { KvKey } from "./kv.js";
+import { MessageQueue } from "./mq.js";
+import { Federation, FederationOptions } from "./federation.js";
+import { Span, TracerProvider } from "@opentelemetry/api";
+
+//#region federation/middleware.d.ts
+/**
+* Options for {@link createFederation} function.
+* @typeParam TContextData The type of the context data.
+* @since 0.10.0
+* @deprecated Use {@link FederationOptions} instead.
+*/
+
+/**
+ * Options for {@link createFederation} function.
+ * @typeParam TContextData The type of the context data.
+ * @since 0.10.0
+ * @deprecated Use {@link FederationOptions} instead.
+ */
+interface CreateFederationOptions<TContextData> extends FederationOptions<TContextData> {}
+/**
+ * Configures the task queues for sending and receiving activities.
+ * @since 1.3.0
+ */
+interface FederationQueueOptions {
+  /**
+   * The message queue for incoming activities.  If not provided, incoming
+   * activities will not be queued and will be processed immediately.
+   */
+  inbox?: MessageQueue;
+  /**
+   * The message queue for outgoing activities.  If not provided, outgoing
+   * activities will not be queued and will be sent immediately.
+   */
+  outbox?: MessageQueue;
+  /**
+   * The message queue for fanning out outgoing activities.  If not provided,
+   * outgoing activities will not be fanned out in the background, but will be
+   * fanned out immediately, which causes slow response times on
+   * {@link Context.sendActivity} calls.
+   */
+  fanout?: MessageQueue;
+}
+/**
+ * Prefixes for namespacing keys in the Deno KV store.
+ */
+interface FederationKvPrefixes {
+  /**
+   * The key prefix used for storing whether activities have already been
+   * processed or not.
+   * @default `["_fedify", "activityIdempotence"]`
+   */
+  activityIdempotence: KvKey;
+  /**
+   * The key prefix used for storing remote JSON-LD documents.
+   * @default `["_fedify", "remoteDocument"]`
+   */
+  remoteDocument: KvKey;
+  /**
+   * The key prefix used for caching public keys.
+   * @default `["_fedify", "publicKey"]`
+   * @since 0.12.0
+   */
+  publicKey: KvKey;
+  /**
+   * The key prefix used for caching HTTP Message Signatures specs.
+   * The cached spec is used to reduce the number of requests to make signed
+   * requests ("double-knocking" technique).
+   * @default `["_fedify", "httpMessageSignaturesSpec"]`
+   * @since 1.6.0
+   */
+  httpMessageSignaturesSpec: KvKey;
+}
+/**
+ * Options for {@link CreateFederationOptions.origin} when it is not a string.
+ * @since 1.5.0
+ */
+interface FederationOrigin {
+  /**
+   * The canonical hostname for fediverse handles (which are looked up through
+   * WebFinger).  This is used for WebFinger lookups.  It has to be a valid
+   * hostname, e.g., `"example.com"`.
+   */
+  handleHost: string;
+  /**
+   * The canonical origin for web URLs.  This is used for constructing absolute
+   * URLs.  It has to start with either `"http://"` or `"https://"`, and must
+   * not contain a path or query string, e.g., `"https://example.com"`.
+   */
+  webOrigin: string;
+}
+/**
+ * Create a new {@link Federation} instance.
+ * @param parameters Parameters for initializing the instance.
+ * @returns A new {@link Federation} instance.
+ * @since 0.10.0
+ */
+declare function createFederation<TContextData>(options: CreateFederationOptions<TContextData>): Federation<TContextData>; //#endregion
+export { CreateFederationOptions, FederationKvPrefixes, FederationOrigin, FederationQueueOptions, createFederation as createFederation$1 };