@takosjp/yurucommu-core 3.0.0

package/src/backend/routes/stories/query-helpers.ts

@@ -0,0 +1,482 @@
+import { and, count, eq, inArray, lt, sql } from "drizzle-orm";
+import type { Database } from "../../../db/index.ts";
+import {
+  actorCache,
+  actors,
+  blocks,
+  communityMembers,
+  follows,
+  mutes,
+  objects,
+  storyVotes,
+} from "../../../db/index.ts";
+import type { IObjectStorage } from "../../runtime/types.ts";
+import { objectApId, safeJsonParse } from "../../federation-helpers.ts";
+import {
+  deleteObjectCascade,
+  purgeMediaBlobs,
+} from "../posts/delete-cascade.ts";
+import { chunkForInClause } from "../../lib/chunk.ts";
+
+// Bound the per-run expired-story reap. The cleanup is opportunistic (fired,
+// unawaited, from the hot story-read path), so a hostile followed host that
+// accumulated thousands of now-expired stories must not make a single run load
+// and sequentially cascade the whole backlog. Each run drains up to this many;
+// the rest are reaped on subsequent runs.
+const STORY_CLEANUP_BATCH = 200;
+
+interface VoteResults {
+  [optionIndex: number]: number;
+}
+
+type OverlayPosition = {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+};
+
+type Overlay = {
+  type: string;
+  position: OverlayPosition;
+  oneOf?: unknown[];
+  href?: string;
+};
+
+type StoryAttachment = {
+  type: string;
+  mediaType: string;
+  url: string;
+  r2_key: string;
+  width: number;
+  height: number;
+};
+
+type StoredStoryData = {
+  attachment?: {
+    r2_key?: string;
+    content_type?: string;
+    url?: string;
+    width?: number;
+    height?: number;
+  };
+  displayDuration?: string;
+  caption?: string;
+  overlays?: Overlay[];
+};
+
+type ActorCacheEntry = {
+  preferredUsername: string | null;
+  name: string | null;
+  iconUrl: string | null;
+};
+
+// ---------------------------------------------------------------------------
+// Story lookup helpers
+// ---------------------------------------------------------------------------
+
+/** Resolve a story param (short ID or full URL) to a full ap_id. */
+export function resolveStoryApId(storyId: string, baseUrl: string): string {
+  return storyId.startsWith("http") ? storyId : objectApId(baseUrl, storyId);
+}
+
+/** Find a single Story object by ap_id. Returns null/undefined when not found. */
+export function findStory(db: Database, apId: string) {
+  return db
+    .select()
+    .from(objects)
+    .where(and(eq(objects.apId, apId), eq(objects.type, "Story")))
+    .get();
+}
+
+/**
+ * Whether `viewerApId` may read `story` — and therefore interact with it. A
+ * story's reach mirrors the story read endpoints: the author always; a
+ * community story → an accepted member of that community; a personal story → an
+ * accepted follower of the author. Gates view / vote / like / share so a
+ * non-follower / non-member cannot interact with (notify the author about, or
+ * re-share) a story they were never shown. Anonymous (`null`) never passes.
+ * Fails closed.
+ */
+export async function canViewerReadStory(
+  db: Database,
+  story: { attributedTo: string; communityApId: string | null },
+  viewerApId: string | null | undefined,
+): Promise<boolean> {
+  if (!viewerApId) return false;
+  if (story.attributedTo === viewerApId) return true;
+  if (story.communityApId) {
+    const member = await db
+      .select({ actorApId: communityMembers.actorApId })
+      .from(communityMembers)
+      .where(
+        and(
+          eq(communityMembers.communityApId, story.communityApId),
+          eq(communityMembers.actorApId, viewerApId),
+        ),
+      )
+      .get();
+    return Boolean(member);
+  }
+  const follow = await db
+    .select({ followerApId: follows.followerApId })
+    .from(follows)
+    .where(
+      and(
+        eq(follows.followerApId, viewerApId),
+        eq(follows.followingApId, story.attributedTo),
+        eq(follows.status, "accepted"),
+      ),
+    )
+    .get();
+  return Boolean(follow);
+}
+
+// ---------------------------------------------------------------------------
+// Blocked / muted helpers
+// ---------------------------------------------------------------------------
+
+/** Fetch blocked and muted ap_ids for the given actor. */
+export async function fetchBlockedAndMutedIds(
+  db: Database,
+  actorApId: string,
+): Promise<{ blockedIds: string[]; mutedIds: string[] }> {
+  const [blockRows, muteRows] = await Promise.all([
+    db
+      .select({ blockedApId: blocks.blockedApId })
+      .from(blocks)
+      .where(eq(blocks.blockerApId, actorApId)),
+    db
+      .select({ mutedApId: mutes.mutedApId })
+      .from(mutes)
+      .where(eq(mutes.muterApId, actorApId)),
+  ]);
+
+  return {
+    blockedIds: blockRows.map((b) => b.blockedApId),
+    mutedIds: muteRows.map((m) => m.mutedApId),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Vote helpers
+// ---------------------------------------------------------------------------
+
+/** Get vote counts for a single story, keyed by option index. */
+export async function getVoteCounts(
+  db: Database,
+  storyApId: string,
+): Promise<VoteResults> {
+  const votes = await db
+    .select({
+      optionIndex: storyVotes.optionIndex,
+      count: count(),
+    })
+    .from(storyVotes)
+    .where(eq(storyVotes.storyApId, storyApId))
+    .groupBy(storyVotes.optionIndex);
+
+  return Object.fromEntries(votes.map((v) => [v.optionIndex, v.count]));
+}
+
+/** Sum all vote counts in a VoteResults record. */
+export function sumVotes(votes: VoteResults): number {
+  return Object.values(votes).reduce((sum, count) => sum + count, 0);
+}
+
+/**
+ * Batch-fetch vote counts and (optionally) the current user's votes
+ * for a list of story ap_ids.
+ */
+export async function fetchBatchVotes(
+  db: Database,
+  storyApIds: string[],
+  actorApId?: string,
+): Promise<{
+  allVotes: Record<string, VoteResults>;
+  userVotes: Record<string, number>;
+}> {
+  if (storyApIds.length === 0) {
+    return { allVotes: {}, userVotes: {} };
+  }
+
+  const voteCounts = await db
+    .select({
+      storyApId: storyVotes.storyApId,
+      optionIndex: storyVotes.optionIndex,
+      count: count(),
+    })
+    .from(storyVotes)
+    .where(inArray(storyVotes.storyApId, storyApIds))
+    .groupBy(storyVotes.storyApId, storyVotes.optionIndex);
+
+  const allVotes: Record<string, VoteResults> = {};
+  for (const v of voteCounts) {
+    if (!allVotes[v.storyApId]) allVotes[v.storyApId] = {};
+    allVotes[v.storyApId][v.optionIndex] = v.count;
+  }
+
+  let userVotes: Record<string, number> = {};
+  if (actorApId) {
+    const rows = await db
+      .select({
+        storyApId: storyVotes.storyApId,
+        optionIndex: storyVotes.optionIndex,
+      })
+      .from(storyVotes)
+      .where(
+        and(
+          inArray(storyVotes.storyApId, storyApIds),
+          eq(storyVotes.actorApId, actorApId),
+        ),
+      );
+    userVotes = Object.fromEntries(
+      rows.map((r) => [r.storyApId, r.optionIndex]),
+    );
+  }
+
+  return { allVotes, userVotes };
+}
+
+// ---------------------------------------------------------------------------
+// Actor cache helper
+// ---------------------------------------------------------------------------
+
+/** Fetch cached actor info for remote authors missing a local actor row. */
+export async function fetchActorCache(
+  db: Database,
+  remoteApIds: string[],
+): Promise<Record<string, ActorCacheEntry>> {
+  if (remoteApIds.length === 0) return {};
+
+  const cached = await db
+    .select({
+      apId: actorCache.apId,
+      preferredUsername: actorCache.preferredUsername,
+      name: actorCache.name,
+      iconUrl: actorCache.iconUrl,
+    })
+    .from(actorCache)
+    .where(inArray(actorCache.apId, remoteApIds));
+
+  return Object.fromEntries(
+    cached.map((a) => [
+      a.apId,
+      {
+        preferredUsername: a.preferredUsername,
+        name: a.name,
+        iconUrl: a.iconUrl,
+      },
+    ]),
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Story data cleanup & transformation
+// ---------------------------------------------------------------------------
+
+export async function cleanupExpiredStories(
+  db: Database,
+  media?: IObjectStorage,
+): Promise<number> {
+  const now = new Date().toISOString();
+
+  const expiredStories = await db
+    .select({ apId: objects.apId, attributedTo: objects.attributedTo })
+    .from(objects)
+    .where(and(eq(objects.type, "Story"), lt(objects.endTime, now)))
+    .limit(STORY_CLEANUP_BATCH);
+
+  if (expiredStories.length === 0) return 0;
+
+  const expiredApIds = expiredStories.map((s) => s.apId);
+
+  // Reap every child edge for each expired story through the shared object
+  // cascade (likes / announces / bookmarks / object_recipients / story_views /
+  // story_votes / story_shares + attached media_uploads), so expiry can't
+  // orphan rows the hand-rolled list previously missed (announces, bookmarks,
+  // media). The helper reads each object row, so run it before deleting them.
+  // When a `media` binding is threaded in, the backing R2 blobs are best-effort
+  // purged too so expired-story storage does not leak.
+  const mediaKeys: string[] = [];
+  for (const apId of expiredApIds) {
+    mediaKeys.push(...(await deleteObjectCascade(db, apId, media)));
+  }
+
+  // Delete EXACTLY the cascaded set (chunked for D1's 100-bound-param cap), not a
+  // broad `endTime < now` — with the per-run limit a broad delete could remove a
+  // story whose children weren't reaped this run, orphaning them. Capture the
+  // rows THIS sweep actually removed via RETURNING so the postCount decrement
+  // below is keyed on the real delete, not the earlier SELECT.
+  const deletedAuthors: (string | null)[] = [];
+  for (const chunk of chunkForInClause(expiredApIds)) {
+    const removed = await db
+      .delete(objects)
+      .where(inArray(objects.apId, chunk))
+      .returning({ attributedTo: objects.attributedTo });
+    for (const row of removed) deletedAuthors.push(row.attributedTo);
+  }
+
+  // Mirror story CREATION's postCount +1 (routes.ts) at expiry — the DOMINANT
+  // end-of-life path. Without this, every story a user posts permanently inflates
+  // their profile post_count by 1 once it expires (create bumps, explicit delete
+  // decrements, but expiry forgot to). Decrement each LOCAL author by the number
+  // of THEIR stories THIS sweep actually DELETED (from RETURNING), not the
+  // pre-delete SELECT: D1 serializes writes, so when concurrent isolates race the
+  // same expiry batch only the winning DELETE returns a given row and a losing
+  // isolate's DELETE matches 0 rows — so each story is counted exactly once and
+  // postCount never double-decrements. (The per-isolate in-flight boolean in
+  // routes.ts cannot serialize across Workers isolates.) MAX(0, …) guards
+  // underflow; remote authors have no `actors` row so the update is a no-op.
+  const perAuthor = new Map<string, number>();
+  for (const author of deletedAuthors) {
+    if (author) perAuthor.set(author, (perAuthor.get(author) ?? 0) + 1);
+  }
+  for (const [author, n] of perAuthor) {
+    await db
+      .update(actors)
+      .set({ postCount: sql`MAX(0, ${actors.postCount} - ${n})` })
+      .where(eq(actors.apId, author));
+  }
+
+  // Irreversible R2 purge LAST — after the objects rows are gone.
+  await purgeMediaBlobs(media, mediaKeys);
+
+  return expiredApIds.length;
+}
+
+// ---------------------------------------------------------------------------
+// Overlay validation
+// ---------------------------------------------------------------------------
+
+const POSITION_FIELDS = ["x", "y", "width", "height"] as const;
+
+function isOverlayRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// Bound the overlays payload (count + serialized size). The caption is
+// length-capped at the caller; without this an overlays blob could carry up to
+// the global 1 MiB body cap into the stored + federated story.
+const MAX_OVERLAYS = 20;
+const MAX_OVERLAYS_JSON_LENGTH = 16 * 1024;
+
+export function validateOverlays(overlays: unknown[]): {
+  valid: boolean;
+  error?: string;
+} {
+  if (!Array.isArray(overlays)) {
+    return { valid: false, error: "overlays must be an array" };
+  }
+  if (overlays.length > MAX_OVERLAYS) {
+    return { valid: false, error: `Too many overlays (max ${MAX_OVERLAYS})` };
+  }
+  if (JSON.stringify(overlays).length > MAX_OVERLAYS_JSON_LENGTH) {
+    return { valid: false, error: "overlays payload too large" };
+  }
+
+  let questionCount = 0;
+  for (const [i, raw] of overlays.entries()) {
+    if (!isOverlayRecord(raw)) {
+      return { valid: false, error: `overlay[${i}] must be an object` };
+    }
+    const overlay = raw;
+
+    if (typeof overlay.type !== "string" || overlay.type === "") {
+      return { valid: false, error: `overlay[${i}].type is required` };
+    }
+
+    if (!isOverlayRecord(overlay.position)) {
+      return { valid: false, error: `overlay[${i}].position is required` };
+    }
+
+    const position = overlay.position;
+    for (const field of POSITION_FIELDS) {
+      const val = position[field];
+      if (typeof val !== "number" || val < 0 || val > 1) {
+        return {
+          valid: false,
+          error: `overlay[${i}].position.${field} must be 0.0-1.0`,
+        };
+      }
+    }
+
+    if (overlay.type === "Question") {
+      // At most ONE Question (poll) per story: votes are keyed only by
+      // (storyApId, actorApId) and the tally aggregates purely by optionIndex
+      // with no question dimension, so a second Question would conflate tallies
+      // and be unvoteable. Reject multi-poll stories at creation.
+      questionCount += 1;
+      if (questionCount > 1) {
+        return {
+          valid: false,
+          error: "A story may have at most one Question (poll) overlay",
+        };
+      }
+      const oneOf = overlay.oneOf;
+      if (!Array.isArray(oneOf) || oneOf.length < 2 || oneOf.length > 4) {
+        return {
+          valid: false,
+          error: `overlay[${i}].oneOf must have 2-4 options`,
+        };
+      }
+    }
+
+    if (overlay.type === "Link") {
+      if (typeof overlay.href !== "string" || overlay.href === "") {
+        return { valid: false, error: `overlay[${i}].href is required` };
+      }
+      try {
+        new URL(overlay.href);
+      } catch {
+        return { valid: false, error: `overlay[${i}].href is invalid URL` };
+      }
+    }
+  }
+
+  return { valid: true };
+}
+
+// ---------------------------------------------------------------------------
+// Story data transformation
+// ---------------------------------------------------------------------------
+
+export function transformStoryData(attachmentsJson: string): {
+  attachment: StoryAttachment;
+  caption?: string;
+  displayDuration: string;
+  overlays?: Overlay[];
+} {
+  const stored = safeJsonParse<StoredStoryData>(attachmentsJson, {});
+  const r2Key = stored.attachment?.r2_key;
+  const contentType = stored.attachment?.content_type || "image/jpeg";
+  const externalUrl = stored.attachment?.url;
+
+  let url = "";
+  if (r2Key) {
+    // Strip the known leading `uploads/` prefix explicitly. `String.replace`
+    // with a string argument only removes the first, anywhere-matching
+    // occurrence, which would mangle keys whose remainder contains the token.
+    const UPLOADS_PREFIX = "uploads/";
+    const publicPath = r2Key.startsWith(UPLOADS_PREFIX)
+      ? r2Key.slice(UPLOADS_PREFIX.length)
+      : r2Key;
+    url = `/media/${publicPath}`;
+  } else if (externalUrl) {
+    url = externalUrl;
+  }
+
+  return {
+    attachment: {
+      type: contentType.startsWith("video/") ? "Video" : "Document",
+      mediaType: contentType,
+      url,
+      r2_key: r2Key || "",
+      width: stored.attachment?.width || 1080,
+      height: stored.attachment?.height || 1920,
+    },
+    caption: stored.caption || undefined,
+    displayDuration: stored.displayDuration || "PT5S",
+    overlays: stored.overlays || undefined,
+  };
+}