@fedify/fedify 0.7.0-dev.131 → 0.7.0-dev.133

package/CHANGES.md

@@ -26,16 +26,33 @@ To be released.
     option now responds with `Vary: Accept, Signature` header.
 
  -  Added log messages using the [LogTape] library.  Currently the below
-    categories are used:
+    logger categories are used:
 
      -  `["fedify"]`
      -  `["fedify", "federation"]`
      -  `["fedify", "federation", "inbox"]`
      -  `["fedify", "federation", "outbox"]`
 
+ -  Added `RequestContext.getActor()` method.
+
+ -  Activity Vocabulary classes now have `typeId` static property.
+
+ -  Dispatcher setters and inbox listener setters in `Federation` now take
+    a path as <code>`${string}{handle}${string}`</code> instead of `string`
+    so that it is more type-safe.
+
+ -  Added generalized object dispatchers.  [[#33]]
+
+     -  Added `Federation.setObjectDispatcher()` method.
+     -  Added `ObjectDispatcher` type.
+     -  Added `ObjectAuthorizePredicate` type.
+     -  Added `Context.getObjectUri()` method.
+     -  Added `RequestContext.getObject()` method.
+
 [public addressing]: https://www.w3.org/TR/activitypub/#public-addressing
 [authorized fetch]: https://swicg.github.io/activitypub-http-signature/#authorized-fetch
 [LogTape]: https://github.com/dahlia/logtape
+[#33]: https://github.com/dahlia/fedify/issues/33
 
 
 Version 0.6.1

package/esm/federation/handler.js

@@ -38,6 +38,29 @@ export async function handleActor(request, { handle, context, actorDispatcher, a
         },
     });
 }
+export async function handleObject(request, { values, context, objectDispatcher, authorizePredicate, onNotFound, onNotAcceptable, onUnauthorized, }) {
+    if (objectDispatcher == null)
+        return await onNotFound(request);
+    const object = await objectDispatcher(context, values);
+    if (object == null)
+        return await onNotFound(request);
+    if (!acceptsJsonLd(request))
+        return await onNotAcceptable(request);
+    if (authorizePredicate != null) {
+        const key = await context.getSignedKey();
+        const keyOwner = await context.getSignedKeyOwner();
+        if (!await authorizePredicate(context, values, key, keyOwner)) {
+            return await onUnauthorized(request);
+        }
+    }
+    const jsonLd = await object.toJsonLd(context);
+    return new Response(JSON.stringify(jsonLd), {
+        headers: {
+            "Content-Type": "application/activity+json",
+            Vary: "Accept",
+        },
+    });
+}
 export async function handleCollection(request, { handle, context, collectionCallbacks, onUnauthorized, onNotFound, onNotAcceptable, }) {
     if (collectionCallbacks == null)
         return await onNotFound(request);

package/esm/federation/middleware.js

@@ -7,7 +7,7 @@ import { handleNodeInfo, handleNodeInfoJrd } from "../nodeinfo/handler.js";
 import { fetchDocumentLoader, getAuthenticatedDocumentLoader, kvCache, } from "../runtime/docloader.js";
 import { Activity, CryptographicKey } from "../vocab/mod.js";
 import { handleWebFinger } from "../webfinger/handler.js";
-import { handleActor, handleCollection, handleInbox, } from "./handler.js";
+import { handleActor, handleCollection, handleInbox, handleObject, } from "./handler.js";
 import { Router, RouterError } from "./router.js";
 import { extractInboxes, sendActivity } from "./send.js";
 /**
@@ -25,6 +25,7 @@ export class Federation {
     #router;
     #nodeInfoDispatcher;
     #actorCallbacks;
+    #objectCallbacks;
     #outboxCallbacks;
     #followingCallbacks;
     #followersCallbacks;
@@ -54,6 +55,7 @@ export class Federation {
         this.#router.add("/.well-known/webfinger", "webfinger");
         this.#router.add("/.well-known/nodeinfo", "nodeInfoJrd");
         this.#inboxListeners = new Map();
+        this.#objectCallbacks = {};
         this.#documentLoader = documentLoader ?? kvCache({
             loader: fetchDocumentLoader,
             kv: kv,
@@ -179,6 +181,22 @@ export class Federation {
                 }
                 return new URL(path, url);
             },
+            getObjectUri: (cls, values) => {
+                const callbacks = this.#objectCallbacks[cls.typeId.href];
+                if (callbacks == null) {
+                    throw new RouterError("No object dispatcher registered.");
+                }
+                for (const param of callbacks.parameters) {
+                    if (!(param in values)) {
+                        throw new TypeError(`Missing parameter: ${param}`);
+                    }
+                }
+                const path = this.#router.build(`object:${cls.typeId.href}`, values);
+                if (path == null) {
+                    throw new RouterError("No object dispatcher registered.");
+                }
+                return new URL(path, url);
+            },
             getOutboxUri: (handle) => {
                 const path = this.#router.build("outbox", { handle });
                 if (path == null) {
@@ -250,6 +268,47 @@ export class Federation {
             ...context,
             request,
             url,
+            getActor: async (handle) => {
+                if (this.#actorCallbacks == null ||
+                    this.#actorCallbacks.dispatcher == null) {
+                    throw new Error("No actor dispatcher registered.");
+                }
+                return await this.#actorCallbacks.dispatcher({
+                    ...reqCtx,
+                    getActor(handle2) {
+                        getLogger(["fedify", "federation"]).warn("RequestContext.getActor({getActorHandle}) is invoked from " +
+                            "the actor dispatcher ({actorDispatcherHandle}); " +
+                            "this may cause an infinite loop.", { getActorHandle: handle2, actorDispatcherHandle: handle });
+                        return reqCtx.getActor(handle2);
+                    },
+                }, handle, await context.getActorKey(handle));
+            },
+            getObject: async (cls, values) => {
+                const callbacks = this.#objectCallbacks[cls.typeId.href];
+                if (callbacks == null) {
+                    throw new Error("No object dispatcher registered.");
+                }
+                for (const param of callbacks.parameters) {
+                    if (!(param in values)) {
+                        throw new TypeError(`Missing parameter: ${param}`);
+                    }
+                }
+                return await callbacks.dispatcher({
+                    ...reqCtx,
+                    getObject(cls2, values2) {
+                        getLogger(["fedify", "federation"]).warn("RequestContext.getObject({getObjectClass}, " +
+                            "{getObjectValues}) is invoked from the object dispatcher " +
+                            "({actorDispatcherClass}, {actorDispatcherValues}); " +
+                            "this may cause an infinite loop.", {
+                            getObjectClass: cls2.name,
+                            getObjectValues: values2,
+                            actorDispatcherClass: cls.name,
+                            actorDispatcherValues: values,
+                        });
+                        return reqCtx.getObject(cls2, values2);
+                    },
+                }, values);
+            },
             async getSignedKey() {
                 if (signedKey !== undefined)
                     return signedKey;
@@ -333,6 +392,30 @@ export class Federation {
         };
         return setters;
     }
+    setObjectDispatcher(
+    // deno-lint-ignore no-explicit-any
+    cls, path, dispatcher) {
+        const routeName = `object:${cls.typeId.href}`;
+        if (this.#router.has(routeName)) {
+            throw new RouterError(`Object dispatcher for ${cls.name} already set.`);
+        }
+        const variables = this.#router.add(path, routeName);
+        if (variables.size < 1) {
+            throw new RouterError("Path for object dispatcher must have at least one variable.");
+        }
+        const callbacks = {
+            dispatcher,
+            parameters: variables,
+        };
+        this.#objectCallbacks[cls.typeId.href] = callbacks;
+        const setters = {
+            authorize(predicate) {
+                callbacks.authorizePredicate = predicate;
+                return setters;
+            },
+        };
+        return setters;
+    }
     /**
      * Registers an outbox dispatcher.
      *
@@ -642,7 +725,7 @@ export class Federation {
             return response instanceof Promise ? await response : response;
         }
         let context = this.createContext(request, contextData);
-        switch (route.name) {
+        switch (route.name.replace(/:.*$/, "")) {
             case "webfinger":
                 return await handleWebFinger(request, {
                     context,
@@ -666,6 +749,19 @@ export class Federation {
                     onNotFound,
                     onNotAcceptable,
                 });
+            case "object": {
+                const typeId = route.name.replace(/^object:/, "");
+                const callbacks = this.#objectCallbacks[typeId];
+                return await handleObject(request, {
+                    values: route.values,
+                    context,
+                    objectDispatcher: callbacks?.dispatcher,
+                    authorizePredicate: callbacks?.authorizePredicate,
+                    onUnauthorized,
+                    onNotFound,
+                    onNotAcceptable,
+                });
+            }
             case "outbox":
                 return await handleCollection(request, {
                     handle: route.values.handle,