@fedify/fedify 1.6.0-dev.813 → 1.6.0-experiment.0

package/esm/federation/mod.js

@@ -1,17 +0,0 @@
-/**
- * The federated server framework.
- *
- * @module
- */
-import "../_dnt.polyfills.js";
-export { createFederationBuilder } from "./builder.js";
-export * from "./callback.js";
-export * from "./collection.js";
-export * from "./context.js";
-export * from "./federation.js";
-export { respondWithObject, respondWithObjectIfAcceptable, } from "./handler.js";
-export * from "./kv.js";
-export { createFederation, } from "./middleware.js";
-export * from "./mq.js";
-export * from "./retry.js";
-export * from "./router.js";

package/esm/federation/mq.js

@@ -1,161 +0,0 @@
-// deno-lint-ignore-file no-explicit-any
-/**
- * Additional options for enqueuing a message in a queue.
- *
- * @since 0.5.0
- */
-import * as dntShim from "../_dnt.shims.js";
-/**
- * A message queue that processes messages in the same process.
- * Do not use this in production as it does neither persist messages nor
- * distribute them across multiple processes.
- *
- * @since 0.5.0
- */
-export class InProcessMessageQueue {
-    #messages;
-    #monitors;
-    #pollIntervalMs;
-    /**
-     * Constructs a new {@link InProcessMessageQueue} with the given options.
-     * @param options Additional options for the in-process message queue.
-     */
-    constructor(options = {}) {
-        this.#messages = [];
-        this.#monitors = {};
-        this.#pollIntervalMs = dntShim.Temporal.Duration.from(options.pollInterval ?? { seconds: 5 }).total("millisecond");
-    }
-    enqueue(message, options) {
-        const delay = options?.delay == null
-            ? 0
-            : Math.max(options.delay.total("millisecond"), 0);
-        if (delay > 0) {
-            setTimeout(() => this.enqueue(message, { ...options, delay: undefined }), delay);
-            return Promise.resolve();
-        }
-        this.#messages.push(message);
-        for (const monitorId in this.#monitors) {
-            this.#monitors[monitorId]();
-        }
-        return Promise.resolve();
-    }
-    enqueueMany(messages, options) {
-        if (messages.length === 0)
-            return Promise.resolve();
-        const delay = options?.delay == null
-            ? 0
-            : Math.max(options.delay.total("millisecond"), 0);
-        if (delay > 0) {
-            setTimeout(() => this.enqueueMany(messages, { ...options, delay: undefined }), delay);
-            return Promise.resolve();
-        }
-        this.#messages.push(...messages);
-        for (const monitorId in this.#monitors) {
-            this.#monitors[monitorId]();
-        }
-        return Promise.resolve();
-    }
-    async listen(handler, options = {}) {
-        const signal = options.signal;
-        while (signal == null || !signal.aborted) {
-            while (this.#messages.length > 0) {
-                const message = this.#messages.shift();
-                await handler(message);
-            }
-            await this.#wait(this.#pollIntervalMs, signal);
-        }
-    }
-    #wait(ms, signal) {
-        let timer = null;
-        return Promise.any([
-            new Promise((resolve) => {
-                signal?.addEventListener("abort", () => {
-                    if (timer != null)
-                        clearTimeout(timer);
-                    resolve();
-                }, { once: true });
-                const monitorId = dntShim.crypto.randomUUID();
-                this.#monitors[monitorId] = () => {
-                    delete this.#monitors[monitorId];
-                    if (timer != null)
-                        clearTimeout(timer);
-                    resolve();
-                };
-            }),
-            new Promise((resolve) => timer = setTimeout(resolve, ms)),
-        ]);
-    }
-}
-/**
- * A message queue that processes messages in parallel.  It takes another
- * {@link MessageQueue}, and processes messages in parallel up to a certain
- * number of workers.
- *
- * Actually, it's rather a decorator than a queue itself.
- *
- * Note that the workers do not run in truly parallel, in the sense that they
- * are not running in separate threads or processes.  They are running in the
- * same process, but are scheduled to run in parallel.  Hence, this is useful
- * for I/O-bound tasks, but not for CPU-bound tasks, which is okay for Fedify's
- * workloads.
- *
- * @since 1.0.0
- */
-export class ParallelMessageQueue {
-    queue;
-    workers;
-    /**
-     * Constructs a new {@link ParallelMessageQueue} with the given queue and
-     * number of workers.
-     * @param queue The message queue to use under the hood.  Note that
-     *              {@link ParallelMessageQueue} cannot be nested.
-     * @param workers The number of workers to process messages in parallel.
-     * @throws {TypeError} If the given queue is an instance of
-     *                     {@link ParallelMessageQueue}.
-     */
-    constructor(queue, workers) {
-        if (queue instanceof ParallelMessageQueue) {
-            throw new TypeError("Cannot nest ParallelMessageQueue.");
-        }
-        this.queue = queue;
-        this.workers = workers;
-    }
-    enqueue(message, options) {
-        return this.queue.enqueue(message, options);
-    }
-    async enqueueMany(messages, options) {
-        if (this.queue.enqueueMany == null) {
-            const results = await Promise.allSettled(messages.map((message) => this.queue.enqueue(message, options)));
-            const errors = results
-                .filter((r) => r.status === "rejected")
-                .map((r) => r.reason);
-            if (errors.length > 1) {
-                throw new AggregateError(errors, "Failed to enqueue messages.");
-            }
-            else if (errors.length === 1)
-                throw errors[0];
-            return;
-        }
-        await this.queue.enqueueMany(messages, options);
-    }
-    listen(handler, options = {}) {
-        const workers = new Map();
-        return this.queue.listen(async (message) => {
-            while (workers.size >= this.workers) {
-                const consumedId = await Promise.any(workers.values());
-                workers.delete(consumedId);
-            }
-            const workerId = dntShim.crypto.randomUUID();
-            const promise = this.#work(workerId, handler, message);
-            workers.set(workerId, promise);
-        }, options);
-    }
-    async #work(workerId, handler, message) {
-        await this.#sleep(0);
-        await handler(message);
-        return workerId;
-    }
-    #sleep(ms) {
-        return new Promise((resolve) => setTimeout(resolve, ms));
-    }
-}

package/esm/federation/negotiation.js

@@ -1,92 +0,0 @@
-/*!
- * Adapted directly from negotiator at https://github.com/jshttp/negotiator/
- * which is licensed as follows:
- *
- * (The MIT License)
- *
- * Copyright (c) 2012-2014 Federico Romero
- * Copyright (c) 2012-2014 Isaac Z. Schlueter
- * Copyright (c) 2014-2015 Douglas Christopher Wilson
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * 'Software'), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
- * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-function compareSpecs(a, b) {
-    return (b.q - a.q ||
-        (b.s ?? 0) - (a.s ?? 0) ||
-        (a.o ?? 0) - (b.o ?? 0) ||
-        a.i - b.i ||
-        0);
-}
-function isQuality(spec) {
-    return spec.q > 0;
-}
-const simpleMediaTypeRegExp = /^\s*([^\s\/;]+)\/([^;\s]+)\s*(?:;(.*))?$/;
-function splitKeyValuePair(str) {
-    const [key, value] = str.split("=");
-    return [key.toLowerCase(), value];
-}
-function parseMediaType(str, i) {
-    const match = simpleMediaTypeRegExp.exec(str);
-    if (!match) {
-        return;
-    }
-    const [, type, subtype, parameters] = match;
-    if (!type || !subtype) {
-        return;
-    }
-    const params = Object.create(null);
-    let q = 1;
-    if (parameters) {
-        const kvps = parameters.split(";").map((p) => p.trim()).map(splitKeyValuePair);
-        for (const [key, val] of kvps) {
-            const value = val && val[0] === `"` && val[val.length - 1] === `"`
-                ? val.slice(1, val.length - 1)
-                : val;
-            if (key === "q" && value) {
-                q = parseFloat(value);
-                break;
-            }
-            params[key] = value;
-        }
-    }
-    return { type, subtype, params, i, o: undefined, q, s: undefined };
-}
-function parseAccept(accept) {
-    const accepts = accept.split(",").map((p) => p.trim());
-    const mediaTypes = [];
-    for (const [index, accept] of accepts.entries()) {
-        const mediaType = parseMediaType(accept.trim(), index);
-        if (mediaType) {
-            mediaTypes.push(mediaType);
-        }
-    }
-    return mediaTypes;
-}
-function getFullType(spec) {
-    return `${spec.type}/${spec.subtype}`;
-}
-export function preferredMediaTypes(accept) {
-    const accepts = parseAccept(accept === undefined ? "*/*" : accept ?? "");
-    return accepts
-        .filter(isQuality)
-        .sort(compareSpecs)
-        .map(getFullType);
-}
-// cSpell: ignore Schlueter kvps

package/esm/federation/queue.js

@@ -1 +0,0 @@
-export {};

package/esm/federation/retry.js

@@ -1,34 +0,0 @@
-/**
- * The context passed to a {@link RetryPolicy} callback.
- * @since 0.12.0
- */
-import * as dntShim from "../_dnt.shims.js";
-/**
- * Creates an exponential backoff retry policy.  The delay between retries
- * starts at the `initialDelay` and is multiplied by the `factor` for each
- * subsequent retry, up to the `maxDelay`.  The policy will give up after
- * `maxAttempts` attempts.  The actual delay is randomized to avoid
- * synchronization (jitter).
- * @param options The options for the policy.
- * @returns The retry policy.
- * @since 0.12.0
- */
-export function createExponentialBackoffPolicy(options = {}) {
-    const initialDelay = dntShim.Temporal.Duration.from(options.initialDelay ?? { seconds: 1 });
-    const maxDelay = dntShim.Temporal.Duration.from(options.maxDelay ?? { hours: 12 });
-    const maxAttempts = options.maxAttempts ?? 10;
-    const factor = options.factor ?? 2;
-    const jitter = options.jitter ?? true;
-    return ({ attempts }) => {
-        if (attempts >= maxAttempts)
-            return null;
-        let milliseconds = initialDelay.total("millisecond");
-        milliseconds *= factor ** attempts;
-        if (jitter) {
-            milliseconds *= 1 + Math.random();
-            milliseconds = Math.round(milliseconds);
-        }
-        const delay = dntShim.Temporal.Duration.from({ milliseconds });
-        return dntShim.Temporal.Duration.compare(delay, maxDelay) > 0 ? maxDelay : delay;
-    };
-}

package/esm/federation/router.js

@@ -1,97 +0,0 @@
-// @ts-ignore TS7016
-import { Router as InnerRouter } from "uri-template-router";
-import { parseTemplate } from "url-template";
-/**
- * URL router and constructor based on URI Template
- * ([RFC 6570](https://tools.ietf.org/html/rfc6570)).
- */
-export class Router {
-    #router;
-    #templates;
-    #templateStrings;
-    /**
-     * Whether to ignore trailing slashes when matching paths.
-     * @since 1.6.0
-     */
-    trailingSlashInsensitive;
-    /**
-     * Create a new {@link Router}.
-     * @param options Options for the router.
-     */
-    constructor(options = {}) {
-        this.#router = new InnerRouter();
-        this.#templates = {};
-        this.#templateStrings = {};
-        this.trailingSlashInsensitive = options.trailingSlashInsensitive ?? false;
-    }
-    /**
-     * Checks if a path name exists in the router.
-     * @param name The name of the path.
-     * @returns `true` if the path name exists, otherwise `false`.
-     */
-    has(name) {
-        return name in this.#templates;
-    }
-    /**
-     * Adds a new path rule to the router.
-     * @param template The path pattern.
-     * @param name The name of the path.
-     * @returns The names of the variables in the path pattern.
-     */
-    add(template, name) {
-        if (!template.startsWith("/")) {
-            throw new RouterError("Path must start with a slash.");
-        }
-        const rule = this.#router.addTemplate(template, {}, name);
-        this.#templates[name] = parseTemplate(template);
-        this.#templateStrings[name] = template;
-        return new Set(rule.variables.map((v) => v.varname));
-    }
-    /**
-     * Resolves a path name and values from a URL, if any match.
-     * @param url The URL to resolve.
-     * @returns The name of the path and its values, if any match.  Otherwise,
-     *          `null`.
-     */
-    route(url) {
-        let match = this.#router.resolveURI(url);
-        if (match == null) {
-            if (!this.trailingSlashInsensitive)
-                return null;
-            url = url.endsWith("/") ? url.replace(/\/+$/, "") : `${url}/`;
-            match = this.#router.resolveURI(url);
-            if (match == null)
-                return null;
-        }
-        return {
-            name: match.matchValue,
-            template: this.#templateStrings[match.matchValue],
-            values: match.params,
-        };
-    }
-    /**
-     * Constructs a URL/path from a path name and values.
-     * @param name The name of the path.
-     * @param values The values to expand the path with.
-     * @returns The URL/path, if the name exists.  Otherwise, `null`.
-     */
-    build(name, values) {
-        if (name in this.#templates) {
-            return this.#templates[name].expand(values);
-        }
-        return null;
-    }
-}
-/**
- * An error thrown by the {@link Router}.
- */
-export class RouterError extends Error {
-    /**
-     * Create a new {@link RouterError}.
-     * @param message The error message.
-     */
-    constructor(message) {
-        super(message);
-        this.name = "RouterError";
-    }
-}

package/esm/federation/send.js

@@ -1,129 +0,0 @@
-import { getLogger } from "@logtape/logtape";
-import { SpanKind, SpanStatusCode, trace, } from "@opentelemetry/api";
-import metadata from "../deno.js";
-import { doubleKnock, } from "../sig/http.js";
-/**
- * Extracts the inbox URLs from recipients.
- * @param parameters The parameters to extract the inboxes.
- *                   See also {@link ExtractInboxesParameters}.
- * @returns The inboxes as a map of inbox URL to actor URIs.
- */
-export function extractInboxes({ recipients, preferSharedInbox, excludeBaseUris }) {
-    const inboxes = {};
-    for (const recipient of recipients) {
-        let inbox;
-        let sharedInbox = false;
-        if (preferSharedInbox && recipient.endpoints?.sharedInbox != null) {
-            inbox = recipient.endpoints.sharedInbox;
-            sharedInbox = true;
-        }
-        else {
-            inbox = recipient.inboxId;
-        }
-        if (inbox != null && recipient.id != null) {
-            if (excludeBaseUris != null &&
-                excludeBaseUris.some((u) => u.origin === inbox?.origin)) {
-                continue;
-            }
-            inboxes[inbox.href] ??= { actorIds: new Set(), sharedInbox };
-            inboxes[inbox.href].actorIds.add(recipient.id.href);
-        }
-    }
-    return inboxes;
-}
-/**
- * Sends an {@link Activity} to an inbox.
- *
- * @param parameters The parameters for sending the activity.
- *                   See also {@link SendActivityParameters}.
- * @throws {Error} If the activity fails to send.
- */
-export function sendActivity(options) {
-    const tracerProvider = options.tracerProvider ?? trace.getTracerProvider();
-    const tracer = tracerProvider.getTracer(metadata.name, metadata.version);
-    return tracer.startActiveSpan("activitypub.send_activity", {
-        kind: SpanKind.CLIENT,
-        attributes: {
-            "activitypub.shared_inbox": options.sharedInbox ?? false,
-        },
-    }, async (span) => {
-        if (options.activityId != null) {
-            span.setAttribute("activitypub.activity.id", options.activityId);
-        }
-        if (options.activityType != null) {
-            span.setAttribute("activitypub.activity.type", options.activityType);
-        }
-        try {
-            await sendActivityInternal({ ...options, tracerProvider });
-        }
-        catch (e) {
-            span.setStatus({ code: SpanStatusCode.ERROR, message: String(e) });
-            throw e;
-        }
-        finally {
-            span.end();
-        }
-    });
-}
-async function sendActivityInternal({ activity, activityId, keys, inbox, headers, specDeterminer, tracerProvider, }) {
-    const logger = getLogger(["fedify", "federation", "outbox"]);
-    headers = new Headers(headers);
-    headers.set("Content-Type", "application/activity+json");
-    const request = new Request(inbox, {
-        method: "POST",
-        headers,
-        body: JSON.stringify(activity),
-    });
-    let rsaKey = null;
-    for (const key of keys) {
-        if (key.privateKey.algorithm.name === "RSASSA-PKCS1-v1_5") {
-            rsaKey = key;
-            break;
-        }
-    }
-    if (rsaKey == null) {
-        logger.warn("No supported key found to sign the request to {inbox}.  " +
-            "The request will be sent without a signature.  " +
-            "In order to sign the request, at least one RSASSA-PKCS1-v1_5 key " +
-            "must be provided.", {
-            inbox: inbox.href,
-            keys: keys.map((pair) => ({
-                keyId: pair.keyId.href,
-                privateKey: pair.privateKey,
-            })),
-        });
-    }
-    let response;
-    try {
-        response = rsaKey == null
-            ? await fetch(request)
-            : await doubleKnock(request, rsaKey, { tracerProvider, specDeterminer });
-    }
-    catch (error) {
-        logger.error("Failed to send activity {activityId} to {inbox}:\n{error}", {
-            activityId,
-            inbox: inbox.href,
-            error,
-        });
-        throw error;
-    }
-    if (!response.ok) {
-        let error;
-        try {
-            error = await response.text();
-        }
-        catch (_) {
-            error = "";
-        }
-        logger.error("Failed to send activity {activityId} to {inbox} ({status} " +
-            "{statusText}):\n{error}", {
-            activityId,
-            inbox: inbox.href,
-            status: response.status,
-            statusText: response.statusText,
-            error,
-        });
-        throw new Error(`Failed to send activity ${activityId} to ${inbox.href} ` +
-            `(${response.status} ${response.statusText}):\n${error}`);
-    }
-}

package/esm/mod.js

@@ -1,52 +0,0 @@
-/**
- * Fedify: a fediverse server framework
- * ====================================
- *
- * Fedify is a TypeScript library for building federated server apps
- * powered by [ActivityPub] and other standards, which is so-called [fediverse].
- * It aims to eliminate the complexity and redundant boilerplate code when
- * building a federated server app, so that you can focus on your business
- * logic and user experience.
- *
- * Currently, Fedify provides the following features out of the box:
- *
- * - Type-safe objects for [Activity Vocabulary] (including some vendor-specific
- *   extensions)
- * - [WebFinger] client and server
- * - [HTTP Signatures] & [HTTP Message Signatures]
- * - [Object Integrity Proofs][FEP-8b32] & [Linked Data Signatures]
- * - Middlewares for handling webhooks
- * - [NodeInfo] protocol
- * - Special touch for interoperability with Mastodon and few other popular
- *   fediverse software
- * - Integration with various web frameworks
- * - CLI toolchain for testing and debugging
- *
- * If you want to know more about the project, please take a look at the
- * following resources:
- *
- * - [GitHub](https://github.com/fedify-dev/fedify)
- * - Tutorials: [Learning the basics](https://fedify.dev/tutorial/basics)
- *   & [Creating a microblog](https://fedify.dev/tutorial/microblog)
- * - [Examples](https://github.com/fedify-dev/fedify/tree/main/examples)
- *
- * [ActivityPub]: https://www.w3.org/TR/activitypub/
- * [fediverse]: https://en.wikipedia.org/wiki/Fediverse
- * [Activity Vocabulary]: https://www.w3.org/TR/activitystreams-vocabulary/
- * [WebFinger]: https://datatracker.ietf.org/doc/html/rfc7033
- * [HTTP Signatures]: https://tools.ietf.org/html/draft-cavage-http-signatures-12
- * [HTTP Message Signatures]: https://www.rfc-editor.org/rfc/rfc9421
- * [FEP-8b32]: https://w3id.org/fep/8b32
- * [Linked Data Signatures]: https://web.archive.org/web/20170923124140/https://w3c-dvcg.github.io/ld-signatures/
- * [NodeInfo]: https://nodeinfo.diaspora.software/
- *
- * @module
- */
-import "./_dnt.polyfills.js";
-export * from "./compat/mod.js";
-export * from "./federation/mod.js";
-export * from "./nodeinfo/mod.js";
-export * from "./runtime/mod.js";
-export * from "./sig/mod.js";
-export * from "./vocab/mod.js";
-export { lookupWebFinger } from "./webfinger/mod.js";