@takosjp/yurucommu-core 3.0.0

package/src/backend/routes/posts/transformers.ts

@@ -0,0 +1,161 @@
+import { formatUsername, safeJsonParse } from "../../federation-helpers.ts";
+
+export const MAX_POST_CONTENT_LENGTH = 5000;
+export const MAX_POST_SUMMARY_LENGTH = 500;
+// Bound the attachments payload. PostAttachment is an open-ended record, so cap
+// both the COUNT and the serialized SIZE — the size cap bounds row/federated-doc
+// bloat regardless of internal shape (key count / field length). 16 KiB is ample
+// for MAX_ATTACHMENTS media descriptors with alt text + blurhash.
+export const MAX_ATTACHMENTS = 8;
+export const MAX_ATTACHMENTS_JSON_LENGTH = 16 * 1024;
+
+/** Truncate a string to `max` characters (no-op when already within bounds). */
+export function truncate(s: string, max: number): string {
+  return s.length > max ? s.slice(0, max) : s;
+}
+
+// Remote inbound Note fields are attacker-controlled and were stored verbatim
+// (capped only by the 512 KiB inbox body limit), vs the ~5 KB local ceiling.
+// Truncate to the same local bounds at ingest. These never reject (a 5xx would
+// just make the peer retry); they store a bounded version.
+export function boundInboundContent(content: unknown): string {
+  return typeof content === "string"
+    ? truncate(content, MAX_POST_CONTENT_LENGTH)
+    : "";
+}
+export function boundInboundSummary(summary: unknown): string | null {
+  return typeof summary === "string" && summary.length > 0
+    ? truncate(summary, MAX_POST_SUMMARY_LENGTH)
+    : null;
+}
+/** Drop an oversized inbound attachments blob to "[]" rather than store it. */
+export function boundAttachmentsJson(json: string): string {
+  return json.length > MAX_ATTACHMENTS_JSON_LENGTH ? "[]" : json;
+}
+// Capped at 90 (not 100): a page's object ids are re-queried via
+// `inArray(col, objectApIds)` for like/bookmark enrichment, and Cloudflare D1
+// allows at most 100 bound parameters per query. 90 leaves headroom for the
+// other bound params in those enrichment statements. (Tests run on libsql,
+// whose ~32k ceiling hides this — see lib/blocklist.ts for the same constraint.)
+export const MAX_POSTS_PAGE_LIMIT = 90;
+
+export type PostRow = {
+  ap_id: string;
+  type: string;
+  attributed_to: string;
+  author_username: string | null;
+  author_name: string | null;
+  author_icon_url: string | null;
+  content: string;
+  summary: string | null;
+  attachments_json: string | null;
+  in_reply_to: string | null;
+  visibility: string;
+  community_ap_id: string | null;
+  like_count: number;
+  reply_count: number;
+  announce_count: number;
+  published: string;
+  updated?: string | null;
+  liked?: number | boolean;
+};
+
+export type FormattedPost = {
+  ap_id: string;
+  type: string;
+  author: {
+    ap_id: string;
+    username: string;
+    preferred_username: string | null;
+    name: string | null;
+    icon_url: string | null;
+  };
+  content: string;
+  summary: string | null;
+  attachments: unknown[];
+  in_reply_to: string | null;
+  visibility: string;
+  community_ap_id: string | null;
+  like_count: number;
+  reply_count: number;
+  announce_count: number;
+  published: string;
+  edited_at: string | null;
+  liked: boolean;
+};
+
+const MENTION_REGEX = /@([a-zA-Z0-9_]+(?:@[a-zA-Z0-9.-]+)?)/g;
+
+export function extractMentions(content: string): string[] {
+  const matches = Array.from(content.matchAll(MENTION_REGEX), (m) => m[1]);
+  return [...new Set(matches)];
+}
+
+// Unicode-aware hashtag body (matches the web client tokenizer), so Japanese
+// tags like #海の日 federate as AS2 Hashtag tags too.
+const HASHTAG_REGEX = /#([\p{L}\p{N}_]+)/gu;
+
+export function extractHashtags(content: string): string[] {
+  const matches = Array.from(content.matchAll(HASHTAG_REGEX), (m) => m[1]);
+  // De-duplicate case-insensitively, keeping first-seen casing.
+  const seen = new Set<string>();
+  const out: string[] = [];
+  for (const tag of matches) {
+    const key = tag.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(tag);
+  }
+  return out;
+}
+
+export function formatPost(
+  p: PostRow,
+  currentActorApId?: string,
+): FormattedPost {
+  return {
+    ap_id: p.ap_id,
+    type: p.type,
+    author: {
+      ap_id: p.attributed_to,
+      username: formatUsername(p.attributed_to),
+      preferred_username: p.author_username,
+      name: p.author_name,
+      icon_url: p.author_icon_url,
+    },
+    content: p.content,
+    summary: p.summary,
+    attachments: safeJsonParse(p.attachments_json, []),
+    in_reply_to: p.in_reply_to,
+    visibility: p.visibility,
+    community_ap_id: p.community_ap_id,
+    like_count: p.like_count,
+    reply_count: p.reply_count,
+    announce_count: p.announce_count,
+    published: p.published,
+    // Surfaced only when the post was actually edited (see timeline.formatPost).
+    edited_at: p.updated && p.updated !== p.published ? p.updated : null,
+    liked: currentActorApId ? !!p.liked : false,
+  };
+}
+
+const VALID_VISIBILITIES = new Set([
+  "public",
+  "unlisted",
+  "followers",
+  "direct",
+] as const);
+
+export function normalizeVisibility(
+  value?: string,
+): "public" | "unlisted" | "followers" | "direct" {
+  if (value === "private" || value === "followers_only") return "followers";
+  if (
+    VALID_VISIBILITIES.has(
+      value as "public" | "unlisted" | "followers" | "direct",
+    )
+  ) {
+    return value as "public" | "unlisted" | "followers" | "direct";
+  }
+  return "public";
+}

package/src/backend/routes/posts.ts

@@ -0,0 +1,17 @@
+// Posts, Likes, and Bookmarks routes for Yurucommu backend
+import { Hono } from "hono";
+import type { Env, Variables } from "../types.ts";
+import baseRoutes from "./posts/routes.ts";
+import interactionRoutes from "./posts/interactions.ts";
+
+const posts = new Hono<{ Bindings: Env; Variables: Variables }>();
+
+// Interaction routes FIRST: its only GET is the static `/bookmarks`, which would
+// otherwise be shadowed by baseRoutes' `GET /:id` (matching id="bookmarks" → a
+// 404 "post not found"). interactionRoutes never shadows a base route — its
+// other routes are POST/DELETE `/:id/{like,repost,bookmark}` (two-segment), so a
+// non-matching request falls through to baseRoutes' `/:id` / `/` / `/:id/replies`.
+posts.route("/", interactionRoutes);
+posts.route("/", baseRoutes);
+
+export default posts;

package/src/backend/routes/recommendations.ts

@@ -0,0 +1,88 @@
+import { Hono } from "hono";
+import { sql } from "drizzle-orm";
+import type { Env, Variables } from "../types.ts";
+import { formatUsername } from "../federation-helpers.ts";
+import { CacheTags, CacheTTL, withCache } from "../middleware/cache.ts";
+import { batchLoadActorInfo } from "./communities/membership-shared.ts";
+
+const recommendations = new Hono<{ Bindings: Env; Variables: Variables }>();
+
+/**
+ * GET /api/recommendations/users
+ *
+ * Returns recommended users based on friends-of-friends algorithm.
+ * Finds users followed by people the current user follows,
+ * ranked by number of mutual connections.
+ */
+recommendations.get(
+  "/users",
+  withCache({
+    ttl: CacheTTL.ACTOR_PROFILE,
+    varyByActor: true,
+    cacheTag: CacheTags.ACTOR,
+  }),
+  async (c) => {
+    const actor = c.get("actor");
+    if (!actor) return c.json({ error: "Unauthorized" }, 401);
+
+    const db = c.get("db");
+    const myApId = actor.ap_id;
+
+    const candidates = await db.all<{ ap_id: string; mutual_count: number }>(
+      sql`
+      SELECT f2.following_ap_id AS ap_id, COUNT(DISTINCT f2.follower_ap_id) AS mutual_count
+      FROM follows f1
+      JOIN follows f2 ON f1.following_ap_id = f2.follower_ap_id AND f2.status = 'accepted'
+      WHERE f1.follower_ap_id = ${myApId}
+        AND f1.status = 'accepted'
+        AND f2.following_ap_id != ${myApId}
+        AND f2.following_ap_id NOT IN (
+          SELECT following_ap_id FROM follows
+          WHERE follower_ap_id = ${myApId} AND status IN ('accepted', 'pending')
+        )
+        AND f2.following_ap_id NOT IN (
+          SELECT blocked_ap_id FROM blocks WHERE blocker_ap_id = ${myApId}
+        )
+        AND f2.following_ap_id NOT IN (
+          SELECT muted_ap_id FROM mutes WHERE muter_ap_id = ${myApId}
+        )
+        AND f2.following_ap_id NOT IN (
+          -- Hide deleted AND private/locked (is_private = 1) accounts. A locked
+          -- account opted out of discovery (discoverable:false), and every other
+          -- actor-discovery surface (search.actors, takos-tools searchUsers /
+          -- getUserProfile) excludes is_private = 1 — this friends-of-friends
+          -- panel must match or it leaks the locked account's handle/name/icon.
+          -- is_private lives only on the LOCAL actors table; remote candidates
+          -- (actorCache) are unaffected, same scope as the other surfaces.
+          SELECT ap_id FROM actors WHERE deleted_at IS NOT NULL OR is_private = 1
+        )
+      GROUP BY f2.following_ap_id
+      ORDER BY mutual_count DESC
+      LIMIT 5
+    `,
+    );
+
+    if (candidates.length === 0) return c.json({ users: [] });
+
+    const actorMap = await batchLoadActorInfo(
+      db,
+      candidates.map((r) => r.ap_id),
+    );
+
+    const users = candidates.map((row) => {
+      const info = actorMap.get(row.ap_id);
+      return {
+        ap_id: row.ap_id,
+        preferred_username: info?.preferredUsername ?? null,
+        name: info?.name ?? null,
+        icon_url: info?.iconUrl ?? null,
+        username: formatUsername(row.ap_id),
+        mutual_count: Number(row.mutual_count),
+      };
+    });
+
+    return c.json({ users });
+  },
+);
+
+export default recommendations;