@rmdes/indiekit-endpoint-activitypub 2.15.3 → 3.0.0

package/lib/mastodon/entities/status.js

@@ -0,0 +1,289 @@
+/**
+ * Status entity serializer for Mastodon Client API.
+ *
+ * Converts ap_timeline documents into the Mastodon Status JSON shape.
+ *
+ * CORRECTED field mappings (based on actual extractObjectData output):
+ *   content    <- content.html (NOT contentHtml)
+ *   uri        <- uid (NOT activityUrl)
+ *   account    <- author { name, url, photo, handle, emojis, bot }
+ *   media      <- photo[] + video[] + audio[] (NOT single attachments[])
+ *   card       <- linkPreviews[0] (NOT single card)
+ *   tags       <- category[] (NOT tags[])
+ *   counts     <- counts.boosts, counts.likes, counts.replies
+ *   boost      <- type:"boost" + boostedBy (flat, NOT nested sharedItem)
+ */
+import { serializeAccount } from "./account.js";
+import { sanitizeHtml } from "./sanitize.js";
+
+/**
+ * Serialize an ap_timeline document as a Mastodon Status entity.
+ *
+ * @param {object} item - ap_timeline document
+ * @param {object} options
+ * @param {string} options.baseUrl - Server base URL
+ * @param {Set<string>} [options.favouritedIds] - UIDs the user has liked
+ * @param {Set<string>} [options.rebloggedIds] - UIDs the user has boosted
+ * @param {Set<string>} [options.bookmarkedIds] - UIDs the user has bookmarked
+ * @param {Set<string>} [options.pinnedIds] - UIDs the user has pinned
+ * @returns {object} Mastodon Status entity
+ */
+export function serializeStatus(item, { baseUrl, favouritedIds, rebloggedIds, bookmarkedIds, pinnedIds }) {
+  if (!item) return null;
+
+  const id = item._id.toString();
+  const uid = item.uid || "";
+  const url = item.url || uid;
+
+  // Handle boosts — reconstruct nested reblog wrapper
+  if (item.type === "boost" && item.boostedBy) {
+    // The outer status represents the boost action
+    // The inner status is the original post (the item itself minus boost metadata)
+    const innerItem = { ...item, type: "note", boostedBy: undefined, boostedAt: undefined };
+    const innerStatus = serializeStatus(innerItem, {
+      baseUrl,
+      favouritedIds,
+      rebloggedIds,
+      bookmarkedIds,
+      pinnedIds,
+    });
+
+    return {
+      id,
+      created_at: item.boostedAt || item.createdAt || new Date().toISOString(),
+      in_reply_to_id: null,
+      in_reply_to_account_id: null,
+      sensitive: false,
+      spoiler_text: "",
+      visibility: item.visibility || "public",
+      language: null,
+      uri: uid,
+      url,
+      replies_count: 0,
+      reblogs_count: 0,
+      favourites_count: 0,
+      edited_at: null,
+      favourited: false,
+      reblogged: rebloggedIds?.has(uid) || false,
+      muted: false,
+      bookmarked: false,
+      pinned: false,
+      content: "",
+      filtered: null,
+      reblog: innerStatus,
+      application: null,
+      account: serializeAccount(item.boostedBy, { baseUrl }),
+      media_attachments: [],
+      mentions: [],
+      tags: [],
+      emojis: [],
+      card: null,
+      poll: null,
+    };
+  }
+
+  // Regular status (note, article, question)
+  const content = item.content?.html || item.content?.text || "";
+  const spoilerText = item.summary || "";
+  const sensitive = item.sensitive || false;
+  const visibility = item.visibility || "public";
+  const language = item.language || null;
+  const published = item.published || item.createdAt || new Date().toISOString();
+  const editedAt = item.updated || item.updatedAt || null;
+
+  // Media attachments — merge photo, video, audio arrays
+  const mediaAttachments = [];
+  let attachmentCounter = 0;
+
+  if (item.photo?.length > 0) {
+    for (const p of item.photo) {
+      mediaAttachments.push({
+        id: `${id}-${attachmentCounter++}`,
+        type: "image",
+        url: typeof p === "string" ? p : p.url,
+        preview_url: typeof p === "string" ? p : p.url,
+        remote_url: typeof p === "string" ? p : p.url,
+        text_url: null,
+        meta: buildImageMeta(p),
+        description: typeof p === "object" ? p.alt || "" : "",
+        blurhash: null,
+      });
+    }
+  }
+
+  if (item.video?.length > 0) {
+    for (const v of item.video) {
+      mediaAttachments.push({
+        id: `${id}-${attachmentCounter++}`,
+        type: "video",
+        url: typeof v === "string" ? v : v.url,
+        preview_url: typeof v === "string" ? v : v.url,
+        remote_url: typeof v === "string" ? v : v.url,
+        text_url: null,
+        meta: null,
+        description: typeof v === "object" ? v.alt || "" : "",
+        blurhash: null,
+      });
+    }
+  }
+
+  if (item.audio?.length > 0) {
+    for (const a of item.audio) {
+      mediaAttachments.push({
+        id: `${id}-${attachmentCounter++}`,
+        type: "audio",
+        url: typeof a === "string" ? a : a.url,
+        preview_url: typeof a === "string" ? a : a.url,
+        remote_url: typeof a === "string" ? a : a.url,
+        text_url: null,
+        meta: null,
+        description: typeof a === "object" ? a.alt || "" : "",
+        blurhash: null,
+      });
+    }
+  }
+
+  // Link preview -> card
+  const card = serializeCard(item.linkPreviews?.[0]);
+
+  // Tags from category[]
+  const tags = (item.category || []).map((tag) => ({
+    name: tag,
+    url: `${baseUrl}/tags/${encodeURIComponent(tag)}`,
+  }));
+
+  // Mentions
+  const mentions = (item.mentions || []).map((m) => ({
+    id: "0", // We don't have stable IDs for mentioned accounts
+    username: m.name || "",
+    url: m.url || "",
+    acct: m.name || "",
+  }));
+
+  // Custom emojis
+  const emojis = (item.emojis || []).map((e) => ({
+    shortcode: e.shortcode || "",
+    url: e.url || "",
+    static_url: e.url || "",
+    visible_in_picker: true,
+  }));
+
+  // Counts
+  const repliesCount = item.counts?.replies ?? 0;
+  const reblogsCount = item.counts?.boosts ?? 0;
+  const favouritesCount = item.counts?.likes ?? 0;
+
+  // Poll
+  const poll = serializePoll(item, id);
+
+  // Interaction state
+  const favourited = favouritedIds?.has(uid) || false;
+  const reblogged = rebloggedIds?.has(uid) || false;
+  const bookmarked = bookmarkedIds?.has(uid) || false;
+  const pinned = pinnedIds?.has(uid) || false;
+
+  return {
+    id,
+    created_at: published,
+    in_reply_to_id: item.inReplyTo ? null : null, // TODO: resolve to local ID
+    in_reply_to_account_id: null, // TODO: resolve
+    sensitive,
+    spoiler_text: spoilerText,
+    visibility,
+    language,
+    uri: uid,
+    url,
+    replies_count: repliesCount,
+    reblogs_count: reblogsCount,
+    favourites_count: favouritesCount,
+    edited_at: editedAt || null,
+    favourited,
+    reblogged,
+    muted: false,
+    bookmarked,
+    pinned,
+    content: sanitizeHtml(content),
+    filtered: null,
+    reblog: null,
+    application: null,
+    account: item.author
+      ? serializeAccount(item.author, { baseUrl })
+      : null,
+    media_attachments: mediaAttachments,
+    mentions,
+    tags,
+    emojis,
+    card,
+    poll,
+  };
+}
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+/**
+ * Serialize a linkPreview object as a Mastodon PreviewCard.
+ */
+function serializeCard(preview) {
+  if (!preview) return null;
+
+  return {
+    url: preview.url || "",
+    title: preview.title || "",
+    description: preview.description || "",
+    type: "link",
+    author_name: "",
+    author_url: "",
+    provider_name: preview.domain || "",
+    provider_url: "",
+    html: "",
+    width: 0,
+    height: 0,
+    image: preview.image || null,
+    embed_url: "",
+    blurhash: null,
+    language: null,
+    published_at: null,
+  };
+}
+
+/**
+ * Build image meta object for media attachments.
+ */
+function buildImageMeta(photo) {
+  if (typeof photo === "string") return null;
+  if (!photo.width && !photo.height) return null;
+
+  return {
+    original: {
+      width: photo.width || 0,
+      height: photo.height || 0,
+      size: photo.width && photo.height ? `${photo.width}x${photo.height}` : null,
+      aspect: photo.width && photo.height ? photo.width / photo.height : null,
+    },
+  };
+}
+
+/**
+ * Serialize poll data from a timeline item.
+ */
+function serializePoll(item, statusId) {
+  if (!item.pollOptions?.length) return null;
+
+  const totalVotes = item.pollOptions.reduce((sum, o) => sum + (o.votes || 0), 0);
+
+  return {
+    id: statusId,
+    expires_at: item.pollEndTime || null,
+    expired: item.pollClosed || false,
+    multiple: false,
+    votes_count: totalVotes,
+    voters_count: item.votersCount || null,
+    options: item.pollOptions.map((o) => ({
+      title: o.name || "",
+      votes_count: o.votes || 0,
+    })),
+    emojis: [],
+    voted: false,
+    own_votes: [],
+  };
+}

package/lib/mastodon/helpers/id-mapping.js

@@ -0,0 +1,32 @@
+/**
+ * Deterministic ID mapping for Mastodon Client API.
+ *
+ * Local accounts use MongoDB _id.toString().
+ * Remote actors use sha256(actorUrl).slice(0, 24) for stable IDs
+ * without requiring a dedicated accounts collection.
+ */
+import crypto from "node:crypto";
+
+/**
+ * Generate a deterministic ID for a remote actor URL.
+ * @param {string} actorUrl - The remote actor's URL
+ * @returns {string} 24-character hex ID
+ */
+export function remoteActorId(actorUrl) {
+  return crypto.createHash("sha256").update(actorUrl).digest("hex").slice(0, 24);
+}
+
+/**
+ * Get the Mastodon API ID for an account.
+ * @param {object} actor - Actor object (local profile or remote author)
+ * @param {boolean} isLocal - Whether this is the local profile
+ * @returns {string}
+ */
+export function accountId(actor, isLocal = false) {
+  if (isLocal && actor._id) {
+    return actor._id.toString();
+  }
+  // Remote actors: use URL-based deterministic hash
+  const url = actor.url || actor.actorUrl || "";
+  return url ? remoteActorId(url) : "0";
+}

package/lib/mastodon/helpers/interactions.js

@@ -0,0 +1,278 @@
+/**
+ * Shared interaction logic for like/unlike, boost/unboost, bookmark/unbookmark.
+ *
+ * Extracted from admin controllers (interactions-like.js, interactions-boost.js)
+ * so that both the admin UI and Mastodon Client API can reuse the same core logic.
+ *
+ * Each function accepts a context object instead of Express req/res,
+ * making them transport-agnostic.
+ */
+
+import { resolveAuthor } from "../../resolve-author.js";
+
+/**
+ * Like a post — send Like activity and track in ap_interactions.
+ *
+ * @param {object} params
+ * @param {string} params.targetUrl - URL of the post to like
+ * @param {object} params.federation - Fedify federation instance
+ * @param {string} params.handle - Local actor handle
+ * @param {string} params.publicationUrl - Publication base URL
+ * @param {object} params.collections - MongoDB collections (Map or object)
+ * @param {object} params.interactions - ap_interactions collection
+ * @returns {Promise<{ activityId: string }>}
+ */
+export async function likePost({ targetUrl, federation, handle, publicationUrl, collections, interactions }) {
+  const { Like } = await import("@fedify/fedify/vocab");
+  const ctx = federation.createContext(
+    new URL(publicationUrl),
+    { handle, publicationUrl },
+  );
+
+  const documentLoader = await ctx.getDocumentLoader({ identifier: handle });
+  const recipient = await resolveAuthor(targetUrl, ctx, documentLoader, collections);
+
+  const uuid = crypto.randomUUID();
+  const baseUrl = publicationUrl.replace(/\/$/, "");
+  const activityId = `${baseUrl}/activitypub/likes/${uuid}`;
+
+  const like = new Like({
+    id: new URL(activityId),
+    actor: ctx.getActorUri(handle),
+    object: new URL(targetUrl),
+  });
+
+  if (recipient) {
+    await ctx.sendActivity({ identifier: handle }, recipient, like, {
+      orderingKey: targetUrl,
+    });
+  }
+
+  if (interactions) {
+    await interactions.updateOne(
+      { objectUrl: targetUrl, type: "like" },
+      {
+        $set: {
+          objectUrl: targetUrl,
+          type: "like",
+          activityId,
+          recipientUrl: recipient?.id?.href || "",
+          createdAt: new Date().toISOString(),
+        },
+      },
+      { upsert: true },
+    );
+  }
+
+  return { activityId };
+}
+
+/**
+ * Unlike a post — send Undo(Like) activity and remove from ap_interactions.
+ *
+ * @param {object} params
+ * @param {string} params.targetUrl - URL of the post to unlike
+ * @param {object} params.federation - Fedify federation instance
+ * @param {string} params.handle - Local actor handle
+ * @param {string} params.publicationUrl - Publication base URL
+ * @param {object} params.collections - MongoDB collections
+ * @param {object} params.interactions - ap_interactions collection
+ * @returns {Promise<void>}
+ */
+export async function unlikePost({ targetUrl, federation, handle, publicationUrl, collections, interactions }) {
+  const existing = interactions
+    ? await interactions.findOne({ objectUrl: targetUrl, type: "like" })
+    : null;
+
+  if (!existing) {
+    return;
+  }
+
+  const { Like, Undo } = await import("@fedify/fedify/vocab");
+  const ctx = federation.createContext(
+    new URL(publicationUrl),
+    { handle, publicationUrl },
+  );
+
+  const documentLoader = await ctx.getDocumentLoader({ identifier: handle });
+  const recipient = await resolveAuthor(targetUrl, ctx, documentLoader, collections);
+
+  if (recipient) {
+    const like = new Like({
+      id: existing.activityId ? new URL(existing.activityId) : undefined,
+      actor: ctx.getActorUri(handle),
+      object: new URL(targetUrl),
+    });
+
+    const undo = new Undo({
+      actor: ctx.getActorUri(handle),
+      object: like,
+    });
+
+    await ctx.sendActivity({ identifier: handle }, recipient, undo, {
+      orderingKey: targetUrl,
+    });
+  }
+
+  if (interactions) {
+    await interactions.deleteOne({ objectUrl: targetUrl, type: "like" });
+  }
+}
+
+/**
+ * Boost a post — send Announce activity and track in ap_interactions.
+ *
+ * @param {object} params
+ * @param {string} params.targetUrl - URL of the post to boost
+ * @param {object} params.federation - Fedify federation instance
+ * @param {string} params.handle - Local actor handle
+ * @param {string} params.publicationUrl - Publication base URL
+ * @param {object} params.collections - MongoDB collections
+ * @param {object} params.interactions - ap_interactions collection
+ * @returns {Promise<{ activityId: string }>}
+ */
+export async function boostPost({ targetUrl, federation, handle, publicationUrl, collections, interactions }) {
+  const { Announce } = await import("@fedify/fedify/vocab");
+  const ctx = federation.createContext(
+    new URL(publicationUrl),
+    { handle, publicationUrl },
+  );
+
+  const uuid = crypto.randomUUID();
+  const baseUrl = publicationUrl.replace(/\/$/, "");
+  const activityId = `${baseUrl}/activitypub/boosts/${uuid}`;
+
+  const publicAddress = new URL("https://www.w3.org/ns/activitystreams#Public");
+  const followersUri = ctx.getFollowersUri(handle);
+
+  const announce = new Announce({
+    id: new URL(activityId),
+    actor: ctx.getActorUri(handle),
+    object: new URL(targetUrl),
+    to: publicAddress,
+    cc: followersUri,
+  });
+
+  // Send to followers
+  await ctx.sendActivity({ identifier: handle }, "followers", announce, {
+    preferSharedInbox: true,
+    syncCollection: true,
+    orderingKey: targetUrl,
+  });
+
+  // Also send directly to the original post author
+  const documentLoader = await ctx.getDocumentLoader({ identifier: handle });
+  const recipient = await resolveAuthor(targetUrl, ctx, documentLoader, collections);
+  if (recipient) {
+    try {
+      await ctx.sendActivity({ identifier: handle }, recipient, announce, {
+        orderingKey: targetUrl,
+      });
+    } catch {
+      // Non-critical — follower delivery already happened
+    }
+  }
+
+  if (interactions) {
+    await interactions.updateOne(
+      { objectUrl: targetUrl, type: "boost" },
+      {
+        $set: {
+          objectUrl: targetUrl,
+          type: "boost",
+          activityId,
+          createdAt: new Date().toISOString(),
+        },
+      },
+      { upsert: true },
+    );
+  }
+
+  return { activityId };
+}
+
+/**
+ * Unboost a post — send Undo(Announce) activity and remove from ap_interactions.
+ *
+ * @param {object} params
+ * @param {string} params.targetUrl - URL of the post to unboost
+ * @param {object} params.federation - Fedify federation instance
+ * @param {string} params.handle - Local actor handle
+ * @param {string} params.publicationUrl - Publication base URL
+ * @param {object} params.interactions - ap_interactions collection
+ * @returns {Promise<void>}
+ */
+export async function unboostPost({ targetUrl, federation, handle, publicationUrl, interactions }) {
+  const existing = interactions
+    ? await interactions.findOne({ objectUrl: targetUrl, type: "boost" })
+    : null;
+
+  if (!existing) {
+    return;
+  }
+
+  const { Announce, Undo } = await import("@fedify/fedify/vocab");
+  const ctx = federation.createContext(
+    new URL(publicationUrl),
+    { handle, publicationUrl },
+  );
+
+  const announce = new Announce({
+    id: existing.activityId ? new URL(existing.activityId) : undefined,
+    actor: ctx.getActorUri(handle),
+    object: new URL(targetUrl),
+  });
+
+  const undo = new Undo({
+    actor: ctx.getActorUri(handle),
+    object: announce,
+  });
+
+  await ctx.sendActivity({ identifier: handle }, "followers", undo, {
+    preferSharedInbox: true,
+    syncCollection: true,
+    orderingKey: targetUrl,
+  });
+
+  if (interactions) {
+    await interactions.deleteOne({ objectUrl: targetUrl, type: "boost" });
+  }
+}
+
+/**
+ * Bookmark a post — local-only, no federation.
+ *
+ * @param {object} params
+ * @param {string} params.targetUrl - URL of the post to bookmark
+ * @param {object} params.interactions - ap_interactions collection
+ * @returns {Promise<void>}
+ */
+export async function bookmarkPost({ targetUrl, interactions }) {
+  if (!interactions) return;
+
+  await interactions.updateOne(
+    { objectUrl: targetUrl, type: "bookmark" },
+    {
+      $set: {
+        objectUrl: targetUrl,
+        type: "bookmark",
+        createdAt: new Date().toISOString(),
+      },
+    },
+    { upsert: true },
+  );
+}
+
+/**
+ * Remove a bookmark — local-only, no federation.
+ *
+ * @param {object} params
+ * @param {string} params.targetUrl - URL of the post to unbookmark
+ * @param {object} params.interactions - ap_interactions collection
+ * @returns {Promise<void>}
+ */
+export async function unbookmarkPost({ targetUrl, interactions }) {
+  if (!interactions) return;
+
+  await interactions.deleteOne({ objectUrl: targetUrl, type: "bookmark" });
+}