@fedify/fedify 1.5.0-dev.730 → 1.5.0-dev.732

package/CHANGES.md

@@ -19,6 +19,9 @@ To be released.
         undefined`).
      -  Added `SendActivityOptions.fanout` option.
      -  Added OpenTelemetry instrumented span `activitypub.fanout`.
+     -  The `ForwardActivityOptions` interface became a type alias of
+        `Omit<SendActivityOptions, "fanout"> & { skipIfUnsigned: boolean }`,
+        which is still compatible with the previous version.
 
  -  A `Federation` object now can have a canonical origin for web URLs and
     a canonical host for fediverse handles.  This affects the URLs constructed
@@ -61,6 +64,9 @@ To be released.
      -  Deprecated the fourth parameter of the `ObjectAuthorizePredicate` type
         in favor of the `RequestContext.getSignedKeyOwner()` method.
 
+ -  Added an optional method `enqueueMany()` to `MessageQueue` interface
+    for sending multiple activities at once.
+
  -  Fixed a bug of the `fedify inbox` command where it had failed to render
     the web interface when the `fedify` command was installed using
     `deno install` command from JSR.

package/esm/deno.js

@@ -1,6 +1,6 @@
 export default {
     "name": "@fedify/fedify",
-    "version": "1.5.0-dev.730+390610bf",
+    "version": "1.5.0-dev.732+7b169275",
     "license": "MIT",
     "exports": {
         ".": "./mod.ts",

package/esm/federation/middleware.js

@@ -322,6 +322,11 @@ export class FederationImpl {
         });
     }
     async #listenFanoutMessage(data, message) {
+        const logger = getLogger(["fedify", "federation", "fanout"]);
+        logger.debug("Fanning out activity {activityId} to {inboxes} inbox(es)...", {
+            activityId: message.activityId,
+            inboxes: globalThis.Object.keys(message.inboxes).length,
+        });
         const keys = await Promise.all(message.keys.map(async ({ keyId, privateKey }) => ({
             keyId: new URL(keyId),
             privateKey: await importJwk(privateKey, "private"),
@@ -1284,7 +1289,7 @@ export class FederationImpl {
             this._startQueueInternal(ctx.data);
         const carrier = {};
         propagation.inject(context.active(), carrier);
-        const promises = [];
+        const messages = [];
         for (const inbox in inboxes) {
             const message = {
                 type: "outbox",
@@ -1303,18 +1308,31 @@ export class FederationImpl {
                 },
                 traceContext: carrier,
             };
-            promises.push(this.outboxQueue.enqueue(message));
+            messages.push(message);
+        }
+        const { outboxQueue } = this;
+        if (outboxQueue.enqueueMany == null) {
+            const promises = messages.map((m) => outboxQueue.enqueue(m));
+            const results = await Promise.allSettled(promises);
+            const errors = results
+                .filter((r) => r.status === "rejected")
+                .map((r) => r.reason);
+            if (errors.length > 0) {
+                logger.error("Failed to enqueue activity {activityId} to send later: {errors}", { activityId: activity.id.href, errors });
+                if (errors.length > 1) {
+                    throw new AggregateError(errors, `Failed to enqueue activity ${activityId} to send later.`);
+                }
+                throw errors[0];
+            }
         }
-        const results = await Promise.allSettled(promises);
-        const errors = results
-            .filter((r) => r.status === "rejected")
-            .map((r) => r.reason);
-        if (errors.length > 0) {
-            logger.error("Failed to enqueue activity {activityId} to send later: {errors}", { activityId: activity.id.href, errors });
-            if (errors.length > 1) {
-                throw new AggregateError(errors, `Failed to enqueue activity ${activityId} to send later.`);
+        else {
+            try {
+                await outboxQueue.enqueueMany(messages);
+            }
+            catch (error) {
+                logger.error("Failed to enqueue activity {activityId} to send later: {error}", { activityId: activity.id.href, error });
+                throw error;
             }
-            throw errors[0];
         }
     }
     fetch(request, options) {
@@ -2511,7 +2529,7 @@ export class InboxContextImpl extends ContextImpl {
         }
         const carrier = {};
         propagation.inject(context.active(), carrier);
-        const promises = [];
+        const messages = [];
         for (const inbox in inboxes) {
             const message = {
                 type: "outbox",
@@ -2528,18 +2546,31 @@ export class InboxContextImpl extends ContextImpl {
                 headers: {},
                 traceContext: carrier,
             };
-            promises.push(this.federation.outboxQueue.enqueue(message));
-        }
-        const results = await Promise.allSettled(promises);
-        const errors = results
-            .filter((r) => r.status === "rejected")
-            .map((r) => r.reason);
-        if (errors.length > 0) {
-            logger.error("Failed to enqueue activity {activityId} to forward later:\n{errors}", { activityId: this.activityId, errors });
-            if (errors.length > 1) {
-                throw new AggregateError(errors, `Failed to enqueue activity ${this.activityId} to forward later.`);
-            }
-            throw errors[0];
+            messages.push(message);
+        }
+        const { outboxQueue } = this.federation;
+        if (outboxQueue.enqueueMany == null) {
+            const promises = messages.map((m) => outboxQueue.enqueue(m));
+            const results = await Promise.allSettled(promises);
+            const errors = results
+                .filter((r) => r.status === "rejected")
+                .map((r) => r.reason);
+            if (errors.length > 0) {
+                logger.error("Failed to enqueue activity {activityId} to forward later:\n{errors}", { activityId: this.activityId, errors });
+                if (errors.length > 1) {
+                    throw new AggregateError(errors, `Failed to enqueue activity ${this.activityId} to forward later.`);
+                }
+                throw errors[0];
+            }
+        }
+        else {
+            try {
+                await outboxQueue.enqueueMany(messages);
+            }
+            catch (error) {
+                logger.error("Failed to enqueue activity {activityId} to forward later:\n{error}", { activityId: this.activityId, error });
+                throw error;
+            }
         }
     }
 }

package/esm/federation/mq.js

@@ -39,6 +39,22 @@ export class InProcessMessageQueue {
         }
         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) {
@@ -107,6 +123,21 @@ export class ParallelMessageQueue {
     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) => {