@fedify/fedify 1.6.0-dev.814 → 1.6.0

package/dist/testing/mod.js

@@ -0,0 +1,136 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { configure, getConsoleSink, reset } from "@logtape/logtape";
+import { test } from "node:test";
+
+//#region testing/mod.ts
+function test$1(name, options, fn) {
+	const def = typeof name === "string" ? typeof options === "function" ? {
+		name,
+		fn: options
+	} : {
+		name,
+		...options,
+		fn
+	} : name;
+	const func = def.fn;
+	if ("Deno" in globalThis) Deno.test({
+		...def,
+		async fn(t) {
+			const records = [];
+			await configure({
+				sinks: {
+					buffer(record) {
+						if (record.category.length > 1 && record.category[0] === "logtape" && record.category[1] === "meta") return;
+						records.push(record);
+					},
+					console: getConsoleSink()
+				},
+				filters: {},
+				loggers: [{
+					category: [],
+					sinks: [Deno.env.get("LOG") === "always" ? "console" : "buffer"]
+				}]
+			});
+			try {
+				await func(t);
+			} catch (e) {
+				const consoleSink = getConsoleSink();
+				for (const record of records) consoleSink(record);
+				throw e;
+			} finally {
+				await reset();
+			}
+		}
+	});
+	else if ("Bun" in globalThis) {
+		let failed = void 0;
+		async function step(defOrNameOrFn, fn$2) {
+			let def$1;
+			if (typeof defOrNameOrFn === "string") def$1 = {
+				name: defOrNameOrFn,
+				fn: fn$2
+			};
+			else if (typeof defOrNameOrFn === "function") def$1 = {
+				name: defOrNameOrFn.name,
+				fn: defOrNameOrFn
+			};
+			else def$1 = defOrNameOrFn;
+			if (def$1.ignore) return true;
+			try {
+				await def$1.fn({
+					name: def$1.name,
+					origin: "",
+					step
+				});
+			} catch (e) {
+				failed ??= e;
+				return false;
+			}
+			return true;
+		}
+		const ctx = {
+			name: def.name,
+			origin: "",
+			step
+		};
+		async function fn$1() {
+			await def.fn(ctx);
+			if (failed) throw failed;
+		}
+		const bunTest = Bun.jest(caller()).test;
+		if (def.ignore) bunTest.skip(def.name, fn$1);
+		else if (def.only) bunTest.only(def.name, fn$1);
+		else bunTest(def.name, fn$1);
+	} else test(def.name, {
+		only: def.only,
+		skip: def.ignore
+	}, async (t) => {
+		await def.fn(intoDenoTestContext(def.name, t));
+	});
+}
+function intoDenoTestContext(name, ctx) {
+	async function step(defOrNameOrFn, fn) {
+		let def;
+		if (typeof defOrNameOrFn === "string") def = {
+			name: defOrNameOrFn,
+			fn
+		};
+		else if (typeof defOrNameOrFn === "function") def = {
+			name: defOrNameOrFn.name,
+			fn: defOrNameOrFn
+		};
+		else def = defOrNameOrFn;
+		let failed = false;
+		await ctx.test(def.name, async (ctx2) => {
+			try {
+				await def.fn(intoDenoTestContext(def.name, ctx2));
+			} catch (e) {
+				failed = true;
+				throw e;
+			}
+		});
+		return failed;
+	}
+	const denoCtx = {
+		name,
+		origin: ctx.filePath ?? "",
+		step
+	};
+	return denoCtx;
+}
+/** Retrieve caller test file. */
+function caller() {
+	const Trace = Error;
+	const _ = Trace.prepareStackTrace;
+	Trace.prepareStackTrace = (_$1, stack$1) => stack$1;
+	const { stack } = new Error();
+	Trace.prepareStackTrace = _;
+	const caller$1 = stack[2];
+	return caller$1.getFileName().replaceAll("\\", "/");
+}
+
+//#endregion
+export { test$1 as test };

package/dist/vocab/actor.d.ts

@@ -0,0 +1,133 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { URLPattern } from "urlpattern-polyfill";
+import { GetUserAgentOptions } from "../runtime/docloader.js";
+import { Application$1 as Application, Group$1 as Group, Organization$1 as Organization, Person$1 as Person, Service$1 as Service } from "./vocab.js";
+import { TracerProvider } from "@opentelemetry/api";
+
+//#region vocab/actor.d.ts
+/**
+* Actor types are {@link Object} types that are capable of performing
+* activities.
+*/
+/**
+ * Actor types are {@link Object} types that are capable of performing
+ * activities.
+ */
+type Actor = Application | Group | Organization | Person | Service;
+/**
+ * Checks if the given object is an {@link Actor}.
+ * @param object The object to check.
+ * @returns `true` if the given object is an {@link Actor}.
+ */
+declare function isActor(object: unknown): object is Actor;
+/**
+ * A string representation of an actor type name.
+ */
+type ActorTypeName = "Application" | "Group" | "Organization" | "Person" | "Service";
+/**
+ * Gets the type name of the given actor.
+ * @param actor The actor to get the type name of.
+ * @returns The type name of the given actor.
+ */
+declare function getActorTypeName(actor: Actor): ActorTypeName;
+/**
+ * Gets the actor class by the given type name.
+ * @param typeName The type name to get the actor class by.
+ * @returns The actor class by the given type name.
+ */
+declare function getActorClassByTypeName(typeName: ActorTypeName): typeof Application | typeof Group | typeof Organization | typeof Person | typeof Service;
+/**
+ * Options for {@link getActorHandle}.
+ * @since 1.3.0
+ */
+interface GetActorHandleOptions extends NormalizeActorHandleOptions {
+  /**
+   * The options for making `User-Agent` header.
+   * If a string is given, it is used as the `User-Agent` header value.
+   * If an object is given, it is passed to {@link getUserAgent} to generate
+   * the `User-Agent` header value.
+   * @since 1.3.0
+   */
+  userAgent?: GetUserAgentOptions | string;
+  /**
+   * The OpenTelemetry tracer provider.  If omitted, the global tracer provider
+   * is used.
+   * @since 1.3.0
+   */
+  tracerProvider?: TracerProvider;
+}
+/**
+ * Gets the actor handle, of the form `@username@domain`, from the given actor
+ * or an actor URI.
+ *
+ * @example
+ * ``` typescript
+ * // Get the handle of an actor object:
+ * await getActorHandle(
+ *   new Person({ id: new URL("https://fosstodon.org/users/hongminhee") })
+ * );
+ *
+ * // Get the handle of an actor URI:
+ * await getActorHandle(new URL("https://fosstodon.org/users/hongminhee"));
+ * ```
+ *
+ * @param actor The actor or actor URI to get the handle from.
+ * @param options The extra options for getting the actor handle.
+ * @returns The actor handle.  It starts with `@` and is followed by the
+ *          username and domain, separated by `@` by default (it can be
+ *          customized with the options).
+ * @throws {TypeError} If the actor does not have enough information to get the
+ *                     handle.
+ * @since 0.4.0
+ */
+declare function getActorHandle(actor: Actor | URL, options?: GetActorHandleOptions): Promise<`@${string}@${string}` | `${string}@${string}`>;
+/**
+ * Options for {@link normalizeActorHandle}.
+ * @since 0.9.0
+ */
+interface NormalizeActorHandleOptions {
+  /**
+   * Whether to trim the leading `@` from the actor handle.  Turned off by
+   * default.
+   */
+  trimLeadingAt?: boolean;
+  /**
+   * Whether to convert the domain part of the actor handle to punycode, if it
+   * is an internationalized domain name.  Turned off by default.
+   */
+  punycode?: boolean;
+}
+/**
+ * Normalizes the given actor handle.
+ * @param handle The full handle of the actor to normalize.
+ * @param options The options for normalizing the actor handle.
+ * @returns The normalized actor handle.
+ * @throws {TypeError} If the actor handle is invalid.
+ * @since 0.9.0
+ */
+declare function normalizeActorHandle(handle: string, options?: NormalizeActorHandleOptions): `@${string}@${string}` | `${string}@${string}`;
+/**
+ * The object that can be a recipient of an activity.
+ *
+ * Note that every {@link Actor} is also a {@link Recipient}.
+ */
+interface Recipient {
+  /**
+   * The URI of the actor.
+   */
+  readonly id: URL | null;
+  /**
+   * The URI of the actor's inbox.
+   */
+  readonly inboxId: URL | null;
+  /**
+   * The endpoints of the actor.
+   */
+  readonly endpoints?: {
+    /**
+     * The URI of the actor's shared inbox.
+     */
+    sharedInbox: URL | null;
+  } | null;
+} //#endregion
+export { Actor, ActorTypeName, GetActorHandleOptions, NormalizeActorHandleOptions, Recipient, getActorClassByTypeName as getActorClassByTypeName$1, getActorHandle as getActorHandle$1, getActorTypeName as getActorTypeName$1, isActor as isActor$1, normalizeActorHandle as normalizeActorHandle$1 };

package/dist/vocab/actor.js

@@ -0,0 +1,148 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { deno_default } from "../deno.js";
+import { getTypeId } from "./type.js";
+import { Application, Group, Organization, Person, Service } from "./vocab.js";
+import { lookupWebFinger } from "../webfinger/lookup.js";
+import { SpanStatusCode, trace } from "@opentelemetry/api";
+import { domainToASCII, domainToUnicode } from "node:url";
+
+//#region vocab/actor.ts
+/**
+* Checks if the given object is an {@link Actor}.
+* @param object The object to check.
+* @returns `true` if the given object is an {@link Actor}.
+*/
+function isActor(object) {
+	return object instanceof Application || object instanceof Group || object instanceof Organization || object instanceof Person || object instanceof Service;
+}
+/**
+* Gets the type name of the given actor.
+* @param actor The actor to get the type name of.
+* @returns The type name of the given actor.
+*/
+function getActorTypeName(actor) {
+	if (actor instanceof Application) return "Application";
+	else if (actor instanceof Group) return "Group";
+	else if (actor instanceof Organization) return "Organization";
+	else if (actor instanceof Person) return "Person";
+	else if (actor instanceof Service) return "Service";
+	throw new Error("Unknown actor type.");
+}
+/**
+* Gets the actor class by the given type name.
+* @param typeName The type name to get the actor class by.
+* @returns The actor class by the given type name.
+*/
+function getActorClassByTypeName(typeName) {
+	switch (typeName) {
+		case "Application": return Application;
+		case "Group": return Group;
+		case "Organization": return Organization;
+		case "Person": return Person;
+		case "Service": return Service;
+	}
+	throw new Error("Unknown actor type name.");
+}
+/**
+* Gets the actor handle, of the form `@username@domain`, from the given actor
+* or an actor URI.
+*
+* @example
+* ``` typescript
+* // Get the handle of an actor object:
+* await getActorHandle(
+*   new Person({ id: new URL("https://fosstodon.org/users/hongminhee") })
+* );
+*
+* // Get the handle of an actor URI:
+* await getActorHandle(new URL("https://fosstodon.org/users/hongminhee"));
+* ```
+*
+* @param actor The actor or actor URI to get the handle from.
+* @param options The extra options for getting the actor handle.
+* @returns The actor handle.  It starts with `@` and is followed by the
+*          username and domain, separated by `@` by default (it can be
+*          customized with the options).
+* @throws {TypeError} If the actor does not have enough information to get the
+*                     handle.
+* @since 0.4.0
+*/
+async function getActorHandle(actor, options = {}) {
+	const tracerProvider = options.tracerProvider ?? trace.getTracerProvider();
+	const tracer = tracerProvider.getTracer(deno_default.name, deno_default.version);
+	return await tracer.startActiveSpan("activitypub.get_actor_handle", async (span) => {
+		if (isActor(actor)) {
+			if (actor.id != null) span.setAttribute("activitypub.actor.id", actor.id.href);
+			span.setAttribute("activitypub.actor.type", getTypeId(actor).href);
+		}
+		try {
+			return await getActorHandleInternal(actor, options);
+		} catch (error) {
+			span.setStatus({
+				code: SpanStatusCode.ERROR,
+				message: String(error)
+			});
+			throw error;
+		} finally {
+			span.end();
+		}
+	});
+}
+async function getActorHandleInternal(actor, options = {}) {
+	const actorId = actor instanceof URL ? actor : actor.id;
+	if (actorId != null) {
+		const result = await lookupWebFinger(actorId, {
+			userAgent: options.userAgent,
+			tracerProvider: options.tracerProvider
+		});
+		if (result != null) {
+			const aliases = [...result.aliases ?? []];
+			if (result.subject != null) aliases.unshift(result.subject);
+			for (const alias of aliases) {
+				const match = alias.match(/^acct:([^@]+)@([^@]+)$/);
+				if (match != null) {
+					const hostname = new URL(`https://${match[2]}/`).hostname;
+					if (hostname !== actorId.hostname && !await verifyCrossOriginActorHandle(actorId.href, alias, options.userAgent, options.tracerProvider)) continue;
+					return normalizeActorHandle(`@${match[1]}@${match[2]}`, options);
+				}
+			}
+		}
+	}
+	if (!(actor instanceof URL) && actor.preferredUsername != null && actor.id != null) return normalizeActorHandle(`@${actor.preferredUsername}@${actor.id.host}`, options);
+	throw new TypeError("Actor does not have enough information to get the handle.");
+}
+async function verifyCrossOriginActorHandle(actorId, alias, userAgent, tracerProvider) {
+	const response = await lookupWebFinger(alias, {
+		userAgent,
+		tracerProvider
+	});
+	if (response == null) return false;
+	for (const alias$1 of response.aliases ?? []) if (new URL(alias$1).href === actorId) return true;
+	return false;
+}
+/**
+* Normalizes the given actor handle.
+* @param handle The full handle of the actor to normalize.
+* @param options The options for normalizing the actor handle.
+* @returns The normalized actor handle.
+* @throws {TypeError} If the actor handle is invalid.
+* @since 0.9.0
+*/
+function normalizeActorHandle(handle, options = {}) {
+	handle = handle.replace(/^@/, "");
+	const atPos = handle.indexOf("@");
+	if (atPos < 1) throw new TypeError("Invalid actor handle.");
+	let domain = handle.substring(atPos + 1);
+	if (domain.length < 1 || domain.includes("@")) throw new TypeError("Invalid actor handle.");
+	domain = domain.toLowerCase();
+	domain = options.punycode ? domainToASCII(domain) : domainToUnicode(domain);
+	domain = domain.toLowerCase();
+	const user = handle.substring(0, atPos);
+	return options.trimLeadingAt ? `${user}@${domain}` : `@${user}@${domain}`;
+}
+
+//#endregion
+export { getActorClassByTypeName, getActorHandle, getActorTypeName, isActor, normalizeActorHandle };

package/dist/vocab/actor.test.d.ts

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

package/dist/vocab/actor.test.js

@@ -0,0 +1,114 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { Application, Group, Organization, Person, Service } from "./vocab.js";
+import { getActorClassByTypeName, getActorHandle, getActorTypeName, isActor, normalizeActorHandle } from "./actor.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 { test } from "../testing/mod.js";
+import { assertFalse } from "../node_modules/.pnpm/@jsr_std__assert@0.226.0/node_modules/@jsr/std__assert/assert_false.js";
+import { assertRejects } from "../node_modules/.pnpm/@jsr_std__assert@0.226.0/node_modules/@jsr/std__assert/assert_rejects.js";
+import { assertStrictEquals } from "../node_modules/.pnpm/@jsr_std__assert@0.226.0/node_modules/@jsr/std__assert/assert_strict_equals.js";
+import { assertThrows } from "../node_modules/.pnpm/@jsr_std__assert@0.226.0/node_modules/@jsr/std__assert/assert_throws.js";
+import { install, mock, uninstall } from "../node_modules/.pnpm/@jsr_hongminhee__deno-mock-fetch@0.3.2/node_modules/@jsr/hongminhee__deno-mock-fetch/mod.js";
+import { property } from "../node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/check/property/Property.js";
+import { assert$1 } from "../node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/check/runner/Runner.js";
+import { constantFrom } from "../node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/constantFrom.js";
+import { anything } from "../node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/anything.js";
+
+//#region vocab/actor.test.ts
+function actorClass() {
+	return constantFrom(Application, Group, Organization, Person, Service);
+}
+function actorClassAndInstance() {
+	return actorClass().map((cls) => [cls, new cls({})]);
+}
+function actor() {
+	return actorClassAndInstance().map(([, instance]) => instance);
+}
+test("isActor()", () => {
+	assert$1(property(actor(), (actor$1) => assert(isActor(actor$1))));
+	assert$1(property(anything({
+		withBigInt: true,
+		withBoxedValues: true,
+		withDate: true,
+		withMap: true,
+		withNullPrototype: true,
+		withObjectString: true,
+		withSet: true,
+		withTypedArray: true,
+		withSparseArray: true
+	}), (nonActor) => assertFalse(isActor(nonActor))));
+});
+test("getActorTypeName()", () => {
+	assert$1(property(actorClassAndInstance(), ([cls, instance]) => assertEquals(getActorTypeName(instance), cls.name)));
+});
+test("getActorClassByTypeName()", () => {
+	assert$1(property(actorClassAndInstance(), ([cls, instance]) => assertStrictEquals(getActorClassByTypeName(getActorTypeName(instance)), cls)));
+});
+test("getActorHandle()", async (t) => {
+	install();
+	mock("GET@/.well-known/webfinger", (_) => new Response(JSON.stringify({ subject: "acct:johndoe@foo.example.com" }), { headers: { "Content-Type": "application/jrd+json" } }));
+	const actorId = new URL("https://foo.example.com/@john");
+	const actor$1 = new Person({
+		id: actorId,
+		preferredUsername: "john"
+	});
+	await t.step("WebFinger subject", async () => {
+		assertEquals(await getActorHandle(actor$1), "@johndoe@foo.example.com");
+		assertEquals(await getActorHandle(actor$1, { trimLeadingAt: true }), "johndoe@foo.example.com");
+		assertEquals(await getActorHandle(actorId), "@johndoe@foo.example.com");
+		assertEquals(await getActorHandle(actorId, { trimLeadingAt: true }), "johndoe@foo.example.com");
+	});
+	mock("GET@/.well-known/webfinger", (_) => new Response(JSON.stringify({
+		subject: "https://foo.example.com/@john",
+		aliases: ["acct:john@bar.example.com", "acct:johndoe@foo.example.com"]
+	}), { headers: { "Content-Type": "application/jrd+json" } }));
+	await t.step("WebFinger aliases", async () => {
+		assertEquals(await getActorHandle(actor$1), "@johndoe@foo.example.com");
+		assertEquals(await getActorHandle(actor$1, { trimLeadingAt: true }), "johndoe@foo.example.com");
+		assertEquals(await getActorHandle(actorId), "@johndoe@foo.example.com");
+		assertEquals(await getActorHandle(actorId, { trimLeadingAt: true }), "johndoe@foo.example.com");
+	});
+	mock("GET@/.well-known/webfinger", (_) => new Response(JSON.stringify({
+		subject: "acct:john@bar.example.com",
+		aliases: ["https://foo.example.com/@john"]
+	}), { headers: { "Content-Type": "application/jrd+json" } }));
+	await t.step("cross-origin WebFinger resources", async () => {
+		assertEquals(await getActorHandle(actor$1), "@john@bar.example.com");
+	});
+	mock("GET@/.well-known/webfinger", (_) => new Response(null, { status: 404 }));
+	await t.step("no WebFinger", async () => {
+		assertEquals(await getActorHandle(actor$1), "@john@foo.example.com");
+		assertRejects(() => getActorHandle(actorId), TypeError);
+	});
+	uninstall();
+});
+test("normalizeActorHandle()", () => {
+	assertEquals(normalizeActorHandle("@foo@BAR.COM"), "@foo@bar.com");
+	assertEquals(normalizeActorHandle("@BAZ@☃-⌘.com"), "@BAZ@☃-⌘.com");
+	assertEquals(normalizeActorHandle("@qux@xn--maana-pta.com"), "@qux@mañana.com");
+	assertEquals(normalizeActorHandle("@quux@XN--MAANA-PTA.COM"), "@quux@mañana.com");
+	assertEquals(normalizeActorHandle("@quux@MAÑANA.COM"), "@quux@mañana.com");
+	assertEquals(normalizeActorHandle("@foo@BAR.COM", { trimLeadingAt: true }), "foo@bar.com");
+	assertEquals(normalizeActorHandle("@BAZ@☃-⌘.com", { trimLeadingAt: true }), "BAZ@☃-⌘.com");
+	assertEquals(normalizeActorHandle("@qux@xn--maana-pta.com", { trimLeadingAt: true }), "qux@mañana.com");
+	assertEquals(normalizeActorHandle("@quux@XN--MAANA-PTA.COM", { trimLeadingAt: true }), "quux@mañana.com");
+	assertEquals(normalizeActorHandle("@quux@MAÑANA.COM", { trimLeadingAt: true }), "quux@mañana.com");
+	assertEquals(normalizeActorHandle("@foo@BAR.COM", { punycode: true }), "@foo@bar.com");
+	assertEquals(normalizeActorHandle("@BAZ@☃-⌘.com", { punycode: true }), "@BAZ@xn----dqo34k.com");
+	assertEquals(normalizeActorHandle("@qux@xn--maana-pta.com", { punycode: true }), "@qux@xn--maana-pta.com");
+	assertEquals(normalizeActorHandle("@quux@XN--MAANA-PTA.COM", { punycode: true }), "@quux@xn--maana-pta.com");
+	assertEquals(normalizeActorHandle("@quux@MAÑANA.COM", { punycode: true }), "@quux@xn--maana-pta.com");
+	assertThrows(() => normalizeActorHandle(""));
+	assertThrows(() => normalizeActorHandle("@"));
+	assertThrows(() => normalizeActorHandle("foo"));
+	assertThrows(() => normalizeActorHandle("@foo"));
+	assertThrows(() => normalizeActorHandle("@@foo.com"));
+	assertThrows(() => normalizeActorHandle("@foo@"));
+	assertThrows(() => normalizeActorHandle("foo@bar.com@baz.com"));
+	assertThrows(() => normalizeActorHandle("@foo@bar.com@baz.com"));
+});
+
+//#endregion

package/dist/vocab/constants.d.ts

@@ -0,0 +1,24 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { URLPattern } from "urlpattern-polyfill";
+
+//#region vocab/constants.d.ts
+/**
+* The special public collection for [public addressing].  *Do not mutate this
+* object.*
+*
+* [public addressing]: https://www.w3.org/TR/activitypub/#public-addressing
+*
+* @since 0.7.0
+*/
+/**
+ * The special public collection for [public addressing].  *Do not mutate this
+ * object.*
+ *
+ * [public addressing]: https://www.w3.org/TR/activitypub/#public-addressing
+ *
+ * @since 0.7.0
+ */
+declare const PUBLIC_COLLECTION: URL;
+
+//#endregion
+export { PUBLIC_COLLECTION as PUBLIC_COLLECTION$1 };

package/dist/vocab/constants.js

@@ -0,0 +1,17 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+//#region vocab/constants.ts
+/**
+* The special public collection for [public addressing].  *Do not mutate this
+* object.*
+*
+* [public addressing]: https://www.w3.org/TR/activitypub/#public-addressing
+*
+* @since 0.7.0
+*/
+const PUBLIC_COLLECTION = new URL("https://www.w3.org/ns/activitystreams#Public");
+
+//#endregion
+export { PUBLIC_COLLECTION };