@takosjp/yurucommu-core 3.0.0

package/packages/api/src/lib/api/communities.ts

@@ -0,0 +1,329 @@
+import { normalizeActor } from "./normalize.ts";
+import {
+  apiDelete,
+  ApiError,
+  apiFetch,
+  apiPatch,
+  apiPost,
+  assertOk,
+} from "./fetch.ts";
+
+export interface CommunityDetail {
+  ap_id: string;
+  name: string;
+  display_name: string;
+  summary: string | null;
+  icon_url: string | null;
+  visibility: "public" | "private";
+  join_policy: "open" | "invite" | "approval";
+  post_policy: "anyone" | "members" | "mods" | "owners";
+  member_count: number;
+  post_count?: number;
+  created_by: string;
+  created_at: string;
+  is_member: boolean;
+  member_role: "owner" | "moderator" | "member" | null;
+  join_status?: "pending" | null;
+  last_message_at?: string | null;
+}
+
+export interface CommunityMember {
+  ap_id: string;
+  username: string;
+  preferred_username: string;
+  name: string | null;
+  icon_url: string | null;
+  role: "owner" | "moderator" | "member";
+  joined_at: string;
+}
+
+export interface CommunityMessage {
+  id: string;
+  sender: {
+    ap_id: string;
+    username: string;
+    preferred_username: string;
+    name: string | null;
+    icon_url: string | null;
+  };
+  content: string;
+  created_at: string;
+}
+
+export interface JoinCommunityResult {
+  status: "joined" | "pending" | "invite_required";
+}
+
+export interface CommunityJoinRequest {
+  ap_id: string;
+  username: string;
+  preferred_username: string;
+  name: string | null;
+  icon_url: string | null;
+  created_at: string;
+}
+
+export interface CommunityInviteResult {
+  invite_id: string;
+}
+
+export interface CommunityInvite {
+  id: string;
+  invited_ap_id: string | null;
+  invited_by: {
+    ap_id: string;
+    username: string;
+    preferred_username: string;
+    name: string;
+  };
+  created_at: string;
+  expires_at: string | null;
+  used_at: string | null;
+  used_by_ap_id: string | null;
+  is_valid: boolean;
+}
+
+export interface CommunitySettings {
+  display_name?: string;
+  summary?: string;
+  icon_url?: string;
+  visibility?: "public" | "private";
+  join_policy?: "open" | "approval" | "invite";
+  post_policy?: "anyone" | "members" | "mods" | "owners";
+}
+
+const normalizeCommunityMessage = (
+  message: CommunityMessage,
+): CommunityMessage => ({
+  ...message,
+  sender: normalizeActor(message.sender),
+});
+
+export async function fetchCommunities(): Promise<CommunityDetail[]> {
+  const res = await apiFetch("/api/communities");
+  const data = (await res.json()) as { communities?: CommunityDetail[] };
+  return data.communities || [];
+}
+
+export async function fetchCommunity(
+  identifier: string,
+): Promise<CommunityDetail> {
+  const res = await apiFetch(
+    `/api/communities/${encodeURIComponent(identifier)}`,
+  );
+  await assertOk(res, "Community not found");
+  const data = (await res.json()) as { community: CommunityDetail };
+  return data.community;
+}
+
+export async function createCommunity(data: {
+  name: string;
+  display_name?: string;
+  summary?: string;
+}): Promise<CommunityDetail> {
+  const res = await apiPost("/api/communities", data);
+  await assertOk(res, "Failed to create community");
+  const result = (await res.json()) as { community: CommunityDetail };
+  return result.community;
+}
+
+export async function joinCommunity(
+  identifier: string,
+  options?: { inviteId?: string },
+): Promise<JoinCommunityResult> {
+  const body = options?.inviteId ? { invite_id: options.inviteId } : undefined;
+  const res = await apiPost(
+    `/api/communities/${encodeURIComponent(identifier)}/join`,
+    body,
+  );
+  const data = (await res.json().catch(() => ({}))) as {
+    error?: string;
+    status?: string;
+  };
+  if (!res.ok) {
+    throw new ApiError(res.status, data.error || "Failed to join community");
+  }
+  const status: JoinCommunityResult["status"] =
+    data.status === "pending" || data.status === "invite_required"
+      ? data.status
+      : "joined";
+  return { status };
+}
+
+export async function leaveCommunity(identifier: string): Promise<void> {
+  const res = await apiPost(
+    `/api/communities/${encodeURIComponent(identifier)}/leave`,
+  );
+  await assertOk(res, "Failed to leave community");
+}
+
+export async function fetchCommunityMessages(
+  identifier: string,
+  options?: { limit?: number; before?: string },
+): Promise<{ messages: CommunityMessage[]; hasMore: boolean }> {
+  const params = new URLSearchParams();
+  if (options?.limit) params.set("limit", String(options.limit));
+  if (options?.before) params.set("before", options.before);
+  const query = params.toString() ? `?${params}` : "";
+  const res = await apiFetch(
+    `/api/communities/${encodeURIComponent(identifier)}/messages${query}`,
+  );
+  await assertOk(res, "Failed to fetch messages");
+  const data = (await res.json()) as {
+    messages?: CommunityMessage[];
+    has_more?: boolean;
+  };
+  return {
+    messages: (data.messages || []).map(normalizeCommunityMessage),
+    hasMore: data.has_more ?? false,
+  };
+}
+
+export async function sendCommunityMessage(
+  identifier: string,
+  content: string,
+): Promise<CommunityMessage> {
+  const res = await apiPost(
+    `/api/communities/${encodeURIComponent(identifier)}/messages`,
+    { content },
+  );
+  await assertOk(res, "Failed to send message");
+  const data = (await res.json()) as { message: CommunityMessage };
+  return normalizeCommunityMessage(data.message);
+}
+
+export async function fetchCommunityMembers(
+  identifier: string,
+): Promise<CommunityMember[]> {
+  // Request the server's max page (500) so the realistic range of communities
+  // shows its full roster without a load-more affordance — the default page
+  // (100) silently truncated larger communities. A >500-member community still
+  // needs cursor pagination (a documented follow-up); has_more/total in the
+  // response signal when that boundary is hit.
+  const res = await apiFetch(
+    `/api/communities/${encodeURIComponent(identifier)}/members?limit=500`,
+  );
+  await assertOk(res, "Failed to fetch members");
+  const data = (await res.json()) as { members?: CommunityMember[] };
+  return (data.members || []).map(normalizeActor);
+}
+
+export async function fetchCommunityJoinRequests(
+  identifier: string,
+): Promise<CommunityJoinRequest[]> {
+  const res = await apiFetch(
+    `/api/communities/${encodeURIComponent(identifier)}/requests`,
+  );
+  await assertOk(res, "Failed to fetch join requests");
+  const data = (await res.json()) as { requests?: CommunityJoinRequest[] };
+  return (data.requests || []).map(normalizeActor);
+}
+
+export async function acceptCommunityJoinRequest(
+  identifier: string,
+  actorApId: string,
+): Promise<void> {
+  const res = await apiPost(
+    `/api/communities/${encodeURIComponent(identifier)}/requests/accept`,
+    { actor_ap_id: actorApId },
+  );
+  await assertOk(res, "Failed to accept join request");
+}
+
+export async function rejectCommunityJoinRequest(
+  identifier: string,
+  actorApId: string,
+): Promise<void> {
+  const res = await apiPost(
+    `/api/communities/${encodeURIComponent(identifier)}/requests/reject`,
+    { actor_ap_id: actorApId },
+  );
+  await assertOk(res, "Failed to reject join request");
+}
+
+export async function fetchCommunityInvites(
+  identifier: string,
+): Promise<CommunityInvite[]> {
+  const res = await apiFetch(
+    `/api/communities/${encodeURIComponent(identifier)}/invites`,
+  );
+  await assertOk(res, "Failed to fetch invites");
+  const data = (await res.json()) as { invites?: CommunityInvite[] };
+  return (data.invites || []).map((invite: CommunityInvite) => ({
+    ...invite,
+    invited_by: normalizeActor(invite.invited_by),
+  }));
+}
+
+export async function createCommunityInvite(
+  identifier: string,
+  options?: { invited_ap_id?: string; expires_in_hours?: number },
+): Promise<CommunityInviteResult & { expires_at?: string }> {
+  const res = await apiPost(
+    `/api/communities/${encodeURIComponent(identifier)}/invites`,
+    options,
+  );
+  await assertOk(res, "Failed to create invite");
+  return (await res.json()) as CommunityInviteResult & { expires_at?: string };
+}
+
+export async function revokeCommunityInvite(
+  identifier: string,
+  inviteId: string,
+): Promise<void> {
+  const res = await apiDelete(
+    `/api/communities/${encodeURIComponent(identifier)}/invites/${encodeURIComponent(
+      inviteId,
+    )}`,
+  );
+  await assertOk(res, "Failed to revoke invite");
+}
+
+export async function updateCommunitySettings(
+  identifier: string,
+  settings: CommunitySettings,
+): Promise<void> {
+  const res = await apiPatch(
+    `/api/communities/${encodeURIComponent(identifier)}/settings`,
+    settings,
+  );
+  await assertOk(res, "Failed to update community settings");
+}
+
+export async function removeCommunityMember(
+  identifier: string,
+  actorApId: string,
+): Promise<void> {
+  const res = await apiDelete(
+    `/api/communities/${encodeURIComponent(identifier)}/members/${encodeURIComponent(
+      actorApId,
+    )}`,
+  );
+  await assertOk(res, "Failed to remove member");
+}
+
+export async function updateCommunityMemberRole(
+  identifier: string,
+  actorApId: string,
+  role: "owner" | "moderator" | "member",
+): Promise<void> {
+  const res = await apiPatch(
+    `/api/communities/${encodeURIComponent(identifier)}/members/${encodeURIComponent(
+      actorApId,
+    )}`,
+    { role },
+  );
+  await assertOk(res, "Failed to update member role");
+}
+
+export async function deleteCommunityMessage(
+  identifier: string,
+  messageId: string,
+): Promise<void> {
+  const res = await apiDelete(
+    `/api/communities/${encodeURIComponent(identifier)}/messages/${encodeURIComponent(
+      messageId,
+    )}`,
+  );
+  await assertOk(res, "Failed to delete message");
+}

package/packages/api/src/lib/api/dm.test.ts

@@ -0,0 +1,67 @@
+import { expect, test } from "bun:test";
+import { clearYurucommuApiTransport } from "../transport.ts";
+import type { DMMessage } from "../../types/index.ts";
+import { fetchUserDMMessages } from "./dm.ts";
+
+function makeMessage(id: string): DMMessage {
+  return {
+    id,
+    sender: {
+      ap_id: "https://example.com/ap/users/alice",
+      username: "alice@example.com",
+      preferred_username: "alice",
+      name: "Alice",
+      icon_url: null,
+    },
+    content: "hi",
+    attachments: [],
+    created_at: "2026-01-01T00:00:00.000Z",
+  } as unknown as DMMessage;
+}
+
+async function withMockFetch<T>(
+  responseBody: unknown,
+  fn: () => Promise<T>,
+): Promise<T> {
+  const originalFetch = globalThis.fetch;
+  clearYurucommuApiTransport();
+  globalThis.fetch = ((_input: RequestInfo | URL) =>
+    Promise.resolve(
+      new Response(JSON.stringify(responseBody), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      }),
+    )) as typeof fetch;
+  try {
+    return await fn();
+  } finally {
+    globalThis.fetch = originalFetch;
+    clearYurucommuApiTransport();
+  }
+}
+
+// Regression: the DM thread's "load older" affordance depends on the client
+// surfacing the server's `has_more` flag (it was previously discarded).
+test("fetchUserDMMessages surfaces has_more as hasMore and maps messages", async () => {
+  const result = await withMockFetch(
+    {
+      messages: [makeMessage("m1")],
+      conversation_id: "conv-1",
+      has_more: true,
+    },
+    () => fetchUserDMMessages("https://example.com/ap/users/alice"),
+  );
+
+  expect(result.messages.map((m) => m.id)).toEqual(["m1"]);
+  expect(result.conversation_id).toBe("conv-1");
+  expect(result.hasMore).toBe(true);
+});
+
+test("fetchUserDMMessages defaults hasMore to false when the server omits it", async () => {
+  const result = await withMockFetch({ messages: [] }, () =>
+    fetchUserDMMessages("https://example.com/ap/users/alice"),
+  );
+
+  expect(result.messages).toEqual([]);
+  expect(result.hasMore).toBe(false);
+});

package/packages/api/src/lib/api/dm.ts

@@ -0,0 +1,236 @@
+import type { DMMessage } from "../../types/index.ts";
+import { normalizeActor } from "./normalize.ts";
+import { apiDelete, apiFetch, apiPost, assertOk } from "./fetch.ts";
+
+// Contact types for the unified DM view
+export interface DMContact {
+  type: "user" | "community";
+  ap_id: string;
+  username: string;
+  preferred_username: string;
+  name: string | null;
+  icon_url: string | null;
+  conversation_id?: string | null;
+  member_count?: number;
+  last_message: { content: string; is_mine: boolean } | null;
+  last_message_at: string | null;
+  unread_count?: number;
+}
+
+export interface DMContactsResponse {
+  mutual_followers: DMContact[];
+  communities: DMContact[];
+  request_count: number;
+}
+
+export interface DMRequest {
+  id: string;
+  sender: {
+    ap_id: string;
+    username: string;
+    preferred_username: string;
+    name: string | null;
+    icon_url: string | null;
+  };
+  content: string;
+  created_at: string;
+}
+
+const normalizeDmMessage = (message: DMMessage): DMMessage => ({
+  ...message,
+  sender: normalizeActor(message.sender),
+});
+
+const normalizeDmRequest = (request: DMRequest): DMRequest => ({
+  ...request,
+  sender: normalizeActor(request.sender),
+});
+
+// Fetch contacts (followers + communities) - no room creation needed
+export async function fetchDMContacts(): Promise<DMContactsResponse> {
+  const res = await apiFetch("/api/dm/contacts");
+  await assertOk(res, "Failed to load conversations");
+  const data = (await res.json()) as {
+    mutual_followers?: DMContact[];
+    communities?: DMContact[];
+    request_count?: number;
+  };
+  return {
+    mutual_followers: (data.mutual_followers || []).map(normalizeActor),
+    communities: (data.communities || []).map(normalizeActor),
+    request_count: data.request_count || 0,
+  };
+}
+
+// Lightweight unread total for the Messages nav badge. The backend computes the
+// same DM + community-chat unread totals as /contacts (a parity test pins them)
+// but with two COUNT(*) joins and no contact enrichment / previews, so the 30s
+// badge poll does not pay for the full contacts list.
+export interface DMUnreadCount {
+  total: number;
+  dm: number;
+  community: number;
+}
+
+export async function fetchDMUnreadCount(): Promise<DMUnreadCount> {
+  const res = await apiFetch("/api/dm/unread/count");
+  const data = (await res.json()) as Partial<DMUnreadCount>;
+  return {
+    total: data.total || 0,
+    dm: data.dm || 0,
+    community: data.community || 0,
+  };
+}
+
+// Fetch message requests
+export async function fetchDMRequests(): Promise<DMRequest[]> {
+  const res = await apiFetch("/api/dm/requests");
+  await assertOk(res, "Failed to load message requests");
+  const data = (await res.json()) as { requests?: DMRequest[] };
+  return (data.requests || []).map(normalizeDmRequest);
+}
+
+// Reject message request (by sender AP ID, optionally block)
+export async function rejectDMRequest(
+  senderApId: string,
+  block?: boolean,
+): Promise<void> {
+  const res = await apiPost("/api/dm/requests/reject", {
+    sender_ap_id: senderApId,
+    block,
+  });
+  await assertOk(res, "Failed to reject request");
+}
+
+// User-based DM endpoints (no conversation creation needed)
+export async function fetchUserDMMessages(
+  userApId: string,
+  options?: { limit?: number; before?: string },
+): Promise<{
+  messages: DMMessage[];
+  conversation_id: string | null;
+  hasMore: boolean;
+}> {
+  const params = new URLSearchParams();
+  if (options?.limit) params.set("limit", String(options.limit));
+  if (options?.before) params.set("before", options.before);
+  const query = params.toString() ? `?${params}` : "";
+  const res = await apiFetch(
+    `/api/dm/user/${encodeURIComponent(userApId)}/messages${query}`,
+  );
+  const data = (await res.json()) as {
+    messages?: DMMessage[];
+    conversation_id?: string | null;
+    has_more?: boolean;
+  };
+  return {
+    messages: (data.messages || []).map(normalizeDmMessage),
+    conversation_id: data.conversation_id ?? null,
+    hasMore: data.has_more ?? false,
+  };
+}
+
+export async function sendUserDMMessage(
+  userApId: string,
+  content: string,
+): Promise<{ message: DMMessage; conversation_id: string }> {
+  const res = await apiPost(
+    `/api/dm/user/${encodeURIComponent(userApId)}/messages`,
+    { content },
+  );
+  await assertOk(res, "Failed to send message");
+  const data = (await res.json()) as {
+    message: DMMessage;
+    conversation_id: string;
+  };
+  return {
+    message: normalizeDmMessage(data.message),
+    conversation_id: data.conversation_id,
+  };
+}
+
+export async function sendUserDMTyping(userApId: string): Promise<void> {
+  const res = await apiPost(
+    `/api/dm/user/${encodeURIComponent(userApId)}/typing`,
+  );
+  await assertOk(res, "Failed to send typing");
+}
+
+export async function fetchUserDMTyping(
+  userApId: string,
+): Promise<{ is_typing: boolean; last_typed_at: string | null }> {
+  const res = await apiFetch(
+    `/api/dm/user/${encodeURIComponent(userApId)}/typing`,
+  );
+  await assertOk(res, "Failed to fetch typing");
+  const data = (await res.json()) as {
+    is_typing?: boolean;
+    last_typed_at?: string | null;
+  };
+  return {
+    is_typing: !!data.is_typing,
+    last_typed_at: data.last_typed_at ?? null,
+  };
+}
+
+export async function markDMAsRead(userApId: string): Promise<void> {
+  const res = await apiPost(
+    `/api/dm/user/${encodeURIComponent(userApId)}/read`,
+  );
+  await assertOk(res, "Failed to mark as read");
+}
+
+// Archive a one-to-one DM conversation (by the other party's AP-ID). Archived
+// conversations drop out of the inbox + unread count and live under the
+// archived view until unarchived.
+export async function archiveDMConversation(userApId: string): Promise<void> {
+  const res = await apiPost(
+    `/api/dm/user/${encodeURIComponent(userApId)}/archive`,
+  );
+  await assertOk(res, "Failed to archive conversation");
+}
+
+export async function unarchiveDMConversation(userApId: string): Promise<void> {
+  const res = await apiDelete(
+    `/api/dm/user/${encodeURIComponent(userApId)}/archive`,
+  );
+  await assertOk(res, "Failed to unarchive conversation");
+}
+
+export async function fetchArchivedDMConversations(): Promise<DMContact[]> {
+  const res = await apiFetch("/api/dm/archived");
+  await assertOk(res, "Failed to load archived conversations");
+  const data = (await res.json()) as { archived?: Partial<DMContact>[] };
+  // The archived endpoint returns actor-profile fields + conversation_id +
+  // last_message_at (no preview / unread). Normalize to a one-to-one DMContact.
+  return (data.archived || []).map((c) => {
+    const a = normalizeActor(c as DMContact);
+    return {
+      ...a,
+      type: "user" as const,
+      last_message: null,
+      unread_count: 0,
+    };
+  });
+}
+
+// Mark a community (group chat) as read so its unread badge clears.
+export async function markCommunityAsRead(
+  communityApId: string,
+): Promise<void> {
+  const res = await apiPost(
+    `/api/dm/community/${encodeURIComponent(communityApId)}/read`,
+  );
+  await assertOk(res, "Failed to mark as read");
+}
+
+// Resolve a single DM contact (user or community) by AP-ID. Used to render a
+// deep-linked conversation that is not present in the loaded contact list.
+// Returns null when no such actor/community is known.
+export async function fetchDMContact(apId: string): Promise<DMContact | null> {
+  const res = await apiFetch(`/api/dm/contact/${encodeURIComponent(apId)}`);
+  if (res.status === 404) return null;
+  await assertOk(res, "Failed to resolve contact");
+  const data = (await res.json()) as { contact?: DMContact };
+  return data.contact ? normalizeActor(data.contact) : null;
+}