@takosjp/yurucommu-core 3.0.0

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

@@ -0,0 +1,181 @@
+import type { Post } from "../../types/index.ts";
+import { normalizePost } from "./normalize.ts";
+import { apiDelete, apiFetch, apiPatch, apiPost, assertOk } from "./fetch.ts";
+
+type PostListResponse = {
+  posts?: Post[];
+};
+
+type CreatePostResponse = {
+  post: Post;
+};
+
+export type TimelinePage = {
+  posts: Post[];
+  // Opaque composite cursor for the next page (`published\u0000apId`), echoed
+  // verbatim back to the server as `before`. Pass this — NOT a post's ap_id —
+  // to paginate: a bare ap_id decodes as a published-only cursor whose
+  // string comparison against an ISO timestamp matches every row, so the feed
+  // re-serves page 1 forever and never advances.
+  nextCursor: string | null;
+  hasMore: boolean;
+};
+
+export async function fetchTimeline(options?: {
+  limit?: number;
+  before?: string;
+  community?: string;
+}): Promise<TimelinePage> {
+  const params = new URLSearchParams();
+  if (options?.limit) params.set("limit", String(options.limit));
+  if (options?.before) params.set("before", options.before);
+  if (options?.community) params.set("community", options.community);
+  const query = params.toString() ? `?${params}` : "";
+  const res = await apiFetch(`/api/timeline${query}`);
+  // Throw on a non-OK response (the backend returns a JSON `{ error }` body, so
+  // without this res.json() would resolve, posts would be undefined, and the
+  // caller would render an empty "welcome" feed instead of an error+retry UI).
+  await assertOk(res, "Failed to load timeline");
+  const data = (await res.json()) as {
+    posts?: Post[];
+    next_cursor?: string | null;
+    has_more?: boolean;
+  };
+  return {
+    posts: (data.posts || []).map(normalizePost),
+    nextCursor: data.next_cursor ?? null,
+    hasMore: data.has_more ?? false,
+  };
+}
+
+export async function fetchPost(apId: string): Promise<Post> {
+  const res = await apiFetch(`/api/posts/${encodeURIComponent(apId)}`);
+  await assertOk(res, "Post not found");
+  const data = (await res.json()) as { post: Post };
+  return normalizePost(data.post);
+}
+
+export interface RepliesPage {
+  replies: Post[];
+  nextCursor: string | null;
+  hasMore: boolean;
+}
+
+export async function fetchReplies(
+  postApId: string,
+  options?: { before?: string },
+): Promise<RepliesPage> {
+  const params = new URLSearchParams();
+  if (options?.before) params.set("before", options.before);
+  const query = params.toString() ? `?${params}` : "";
+  const res = await apiFetch(
+    `/api/posts/${encodeURIComponent(postApId)}/replies${query}`,
+  );
+  const data = (await res.json()) as {
+    replies?: Post[];
+    next_cursor?: string | null;
+    has_more?: boolean;
+  };
+  return {
+    replies: (data.replies || []).map(normalizePost),
+    nextCursor: data.next_cursor ?? null,
+    hasMore: data.has_more ?? false,
+  };
+}
+
+export async function createPost(data: {
+  content: string;
+  summary?: string;
+  visibility?: string;
+  in_reply_to?: string;
+  community_ap_id?: string;
+  attachments?: {
+    url?: string;
+    r2_key: string;
+    content_type: string;
+    name?: string;
+  }[];
+}): Promise<Post> {
+  const res = await apiPost("/api/posts", data);
+  await assertOk(res, "Failed to create post");
+  const result = (await res.json()) as CreatePostResponse;
+  return normalizePost(result.post);
+}
+
+// Edit your own post's text and/or content warning. The server returns only the
+// changed fields (it stays the authority on what actually persisted); the caller
+// merges them into the post it already holds. `summary: null` clears the CW.
+export async function editPost(
+  apId: string,
+  data: { content?: string; summary?: string | null },
+): Promise<{ content: string; summary: string | null }> {
+  const res = await apiPatch(`/api/posts/${encodeURIComponent(apId)}`, data);
+  await assertOk(res, "Failed to edit post");
+  const result = (await res.json()) as {
+    post: { content: string; summary: string | null };
+  };
+  return { content: result.post.content, summary: result.post.summary };
+}
+
+export async function deletePost(apId: string): Promise<void> {
+  const res = await apiDelete(`/api/posts/${encodeURIComponent(apId)}`);
+  await assertOk(res, "Failed to delete post");
+}
+
+export async function likePost(apId: string): Promise<void> {
+  const res = await apiPost(`/api/posts/${encodeURIComponent(apId)}/like`);
+  await assertOk(res, "Failed to like");
+}
+
+export async function unlikePost(apId: string): Promise<void> {
+  const res = await apiDelete(`/api/posts/${encodeURIComponent(apId)}/like`);
+  await assertOk(res, "Failed to unlike");
+}
+
+export async function repostPost(apId: string): Promise<void> {
+  const res = await apiPost(`/api/posts/${encodeURIComponent(apId)}/repost`);
+  await assertOk(res, "Failed to repost");
+}
+
+export async function unrepostPost(apId: string): Promise<void> {
+  const res = await apiDelete(`/api/posts/${encodeURIComponent(apId)}/repost`);
+  await assertOk(res, "Failed to unrepost");
+}
+
+export async function bookmarkPost(apId: string): Promise<void> {
+  const res = await apiPost(`/api/posts/${encodeURIComponent(apId)}/bookmark`);
+  await assertOk(res, "Failed to bookmark");
+}
+
+export async function unbookmarkPost(apId: string): Promise<void> {
+  const res = await apiDelete(
+    `/api/posts/${encodeURIComponent(apId)}/bookmark`,
+  );
+  await assertOk(res, "Failed to unbookmark");
+}
+
+export interface BookmarksPage {
+  posts: Post[];
+  nextCursor: string | null;
+  hasMore: boolean;
+}
+
+export async function fetchBookmarks(options?: {
+  limit?: number;
+  before?: string;
+}): Promise<BookmarksPage> {
+  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/bookmarks${query}`);
+  const data = (await res.json()) as PostListResponse & {
+    next_cursor?: string | null;
+    has_more?: boolean;
+  };
+  return {
+    posts: (data.posts ?? []).map(normalizePost),
+    nextCursor: data.next_cursor ?? null,
+    hasMore: data.has_more ?? false,
+  };
+}

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

@@ -0,0 +1,22 @@
+import type { Actor } from "../../types/index.ts";
+import { normalizeActor } from "./normalize.ts";
+import { apiFetch } from "./fetch.ts";
+
+export interface RecommendedUser {
+  ap_id: string;
+  preferred_username: string;
+  name: string | null;
+  icon_url: string | null;
+  username: string;
+  mutual_count: number;
+}
+
+export async function fetchRecommendedUsers(): Promise<RecommendedUser[]> {
+  const res = await apiFetch("/api/recommendations/users");
+  if (!res.ok) return [];
+  const data = (await res.json()) as { users?: RecommendedUser[] };
+  return (data.users || []).map((u) => ({
+    ...normalizeActor(u),
+    mutual_count: u.mutual_count,
+  }));
+}

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

@@ -0,0 +1,88 @@
+import type { Actor, Post } from "../../types/index.ts";
+import { normalizeActor, normalizePost } from "./normalize.ts";
+import { apiFetch } from "./fetch.ts";
+
+export interface SearchPageOpts {
+  sort?: string;
+  offset?: number;
+  limit?: number;
+}
+
+export interface Paged<T> {
+  items: T[];
+  hasMore: boolean;
+}
+
+function pageParams(query: string, opts?: SearchPageOpts): string {
+  const params = new URLSearchParams({ q: query });
+  if (opts?.sort) params.set("sort", opts.sort);
+  if (opts?.offset) params.set("offset", String(opts.offset));
+  if (opts?.limit) params.set("limit", String(opts.limit));
+  return params.toString();
+}
+
+export async function searchActors(
+  query: string,
+  opts?: SearchPageOpts,
+): Promise<Paged<Actor>> {
+  const res = await apiFetch(`/api/search/actors?${pageParams(query, opts)}`);
+  const data = (await res.json()) as { actors?: Actor[]; has_more?: boolean };
+  return {
+    items: (data.actors || []).map(normalizeActor),
+    hasMore: data.has_more ?? false,
+  };
+}
+
+export async function searchRemote(query: string): Promise<Actor[]> {
+  const res = await apiFetch(
+    `/api/search/remote?q=${encodeURIComponent(query)}`,
+  );
+  const data = (await res.json()) as { actors?: Actor[] };
+  return (data.actors || []).map(normalizeActor);
+}
+
+export async function searchPosts(
+  query: string,
+  opts?: SearchPageOpts,
+): Promise<Paged<Post>> {
+  const res = await apiFetch(`/api/search/posts?${pageParams(query, opts)}`);
+  const data = (await res.json()) as { posts?: Post[]; has_more?: boolean };
+  return {
+    items: (data.posts || []).map(normalizePost),
+    hasMore: data.has_more ?? false,
+  };
+}
+
+// Exact whole-hashtag search. Unlike searchPosts (a substring/FTS content
+// match, where "#deploy" also hits "#deployed"), this hits the dedicated
+// /search/hashtag/:tag route which matches the tag as a complete token — the
+// behaviour a user expects when they click a #hashtag. Pass the tag WITHOUT the
+// leading '#'.
+export async function searchHashtag(
+  tag: string,
+  opts?: SearchPageOpts,
+): Promise<Paged<Post>> {
+  const params = new URLSearchParams();
+  if (opts?.sort) params.set("sort", opts.sort);
+  if (opts?.offset) params.set("offset", String(opts.offset));
+  if (opts?.limit) params.set("limit", String(opts.limit));
+  const qs = params.toString();
+  const res = await apiFetch(
+    `/api/search/hashtag/${encodeURIComponent(tag)}${qs ? `?${qs}` : ""}`,
+  );
+  const data = (await res.json()) as { posts?: Post[]; has_more?: boolean };
+  return {
+    items: (data.posts || []).map(normalizePost),
+    hasMore: data.has_more ?? false,
+  };
+}
+
+export async function fetchTrendingHashtags(
+  limit = 10,
+): Promise<{ tag: string; count: number }[]> {
+  const res = await apiFetch(`/api/search/hashtags/trending?limit=${limit}`);
+  const data = (await res.json()) as {
+    trending?: { tag: string; count: number }[];
+  };
+  return data.trending || [];
+}

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

@@ -0,0 +1,80 @@
+import type { ActorStories, Story, StoryOverlay } from "../../types/index.ts";
+import { normalizeActorStories, normalizeStory } from "./normalize.ts";
+import { apiDelete, apiFetch, apiPost, assertOk } from "./fetch.ts";
+
+export async function fetchStories(
+  community?: string,
+): Promise<ActorStories[]> {
+  const qs = community ? `?community=${encodeURIComponent(community)}` : "";
+  const res = await apiFetch(`/api/stories${qs}`);
+  await assertOk(res, "Failed to fetch stories");
+  const data = (await res.json()) as { actor_stories?: ActorStories[] };
+  return (data.actor_stories || []).map(normalizeActorStories);
+}
+
+export async function createStory(story: {
+  attachment: { url?: string; r2_key: string; content_type: string };
+  displayDuration: string;
+  caption?: string;
+  overlays?: StoryOverlay[];
+  community_ap_id?: string;
+}): Promise<Story> {
+  const res = await apiPost("/api/stories", story);
+  await assertOk(res, "Failed to create story");
+  const data = (await res.json()) as { story: Story };
+  return normalizeStory(data.story);
+}
+
+export async function deleteStory(apId: string): Promise<void> {
+  const res = await apiPost("/api/stories/delete", { ap_id: apId });
+  await assertOk(res, "Failed to delete story");
+}
+
+export async function markStoryViewed(apId: string): Promise<void> {
+  const res = await apiPost("/api/stories/view", { ap_id: apId });
+  await assertOk(res, "Failed to mark story as viewed");
+}
+
+export async function voteOnStory(
+  apId: string,
+  optionIndex: number,
+): Promise<{
+  votes: Record<number, number>;
+  total: number;
+  user_vote: number;
+}> {
+  const res = await apiPost("/api/stories/vote", {
+    ap_id: apId,
+    option_index: optionIndex,
+  });
+  await assertOk(res, "Failed to vote on story");
+  return (await res.json()) as {
+    votes: Record<number, number>;
+    total: number;
+    user_vote: number;
+  };
+}
+
+export async function likeStory(
+  apId: string,
+): Promise<{ liked: boolean; like_count: number }> {
+  const res = await apiPost(`/api/stories/${encodeURIComponent(apId)}/like`);
+  await assertOk(res, "Failed to like story");
+  return (await res.json()) as { liked: boolean; like_count: number };
+}
+
+export async function unlikeStory(
+  apId: string,
+): Promise<{ liked: boolean; like_count: number }> {
+  const res = await apiDelete(`/api/stories/${encodeURIComponent(apId)}/like`);
+  await assertOk(res, "Failed to unlike story");
+  return (await res.json()) as { liked: boolean; like_count: number };
+}
+
+export async function shareStory(
+  apId: string,
+): Promise<{ shared: boolean; share_count: number }> {
+  const res = await apiPost(`/api/stories/${encodeURIComponent(apId)}/share`);
+  await assertOk(res, "Failed to share story");
+  return (await res.json()) as { shared: boolean; share_count: number };
+}

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

@@ -0,0 +1,15 @@
+export * from "./api/fetch.ts";
+export * from "./api/account.ts";
+export * from "./api/auth.ts";
+export * from "./api/actors.ts";
+export * from "./api/follow.ts";
+export * from "./api/posts.ts";
+export * from "./api/communities.ts";
+export * from "./api/dm.ts";
+export * from "./api/notifications.ts";
+export * from "./api/search.ts";
+export * from "./api/media.ts";
+export * from "./api/stories.ts";
+export * from "./api/recommendations.ts";
+export * from "./api/moderation.ts";
+export * from "./api/normalize.ts";

package/packages/api/src/lib/fetch-with-timeout.ts

@@ -0,0 +1,42 @@
+export const DEFAULT_REQUEST_TIMEOUT_MS = 15_000;
+export const UPLOAD_REQUEST_TIMEOUT_MS = 60_000;
+
+export interface FetchWithTimeoutInit extends RequestInit {
+  timeoutMs?: number;
+}
+
+export async function fetchWithTimeout(
+  input: RequestInfo | URL,
+  init: FetchWithTimeoutInit = {},
+): Promise<Response> {
+  const { timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS, signal, ...rest } = init;
+
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    return fetch(input, { ...rest, signal });
+  }
+
+  const controller = new AbortController();
+  const abortFromSignal = () => controller.abort(signal?.reason);
+
+  if (signal?.aborted) {
+    controller.abort(signal.reason);
+  } else if (signal) {
+    signal.addEventListener("abort", abortFromSignal, { once: true });
+  }
+
+  const timeoutId = globalThis.setTimeout(() => {
+    controller.abort();
+  }, timeoutMs);
+
+  try {
+    return await fetch(input, {
+      ...rest,
+      signal: controller.signal,
+    });
+  } finally {
+    globalThis.clearTimeout(timeoutId);
+    if (signal) {
+      signal.removeEventListener("abort", abortFromSignal);
+    }
+  }
+}

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

@@ -0,0 +1,40 @@
+export interface ApiTransport {
+  resolveUrl(path: string): string;
+  getAuthHeaders(path: string): Record<string, string>;
+  readonly credentials: RequestCredentials;
+}
+
+class DefaultSelfHostedTransport implements ApiTransport {
+  readonly credentials: RequestCredentials = "include";
+
+  resolveUrl(path: string): string {
+    return path;
+  }
+
+  getAuthHeaders(_path: string): Record<string, string> {
+    return {};
+  }
+}
+
+export type ApiTransportResolver = () => ApiTransport;
+
+let activeTransportResolver: ApiTransportResolver = () =>
+  new DefaultSelfHostedTransport();
+
+export function setYurucommuApiTransportResolver(
+  resolver: ApiTransportResolver,
+): void {
+  activeTransportResolver = resolver;
+}
+
+export function setYurucommuApiTransport(transport: ApiTransport): void {
+  activeTransportResolver = () => transport;
+}
+
+export function clearYurucommuApiTransport(): void {
+  activeTransportResolver = () => new DefaultSelfHostedTransport();
+}
+
+export function getYurucommuApiTransport(): ApiTransport {
+  return activeTransportResolver();
+}

package/packages/api/src/social-server.ts

@@ -0,0 +1,47 @@
+import { apiFetch, assertOk } from "./lib/api/fetch.ts";
+import type { Actor } from "./types/index.ts";
+
+export interface SocialServerDiscovery {
+  readonly product: "yurucommu";
+  readonly name: string;
+  readonly server: {
+    readonly id: "yurucommu-server";
+    readonly name: string;
+    readonly canonicalOrigin: string;
+    readonly activitypubOrigin: string;
+  };
+  readonly clients: readonly {
+    readonly id: "yurucommu" | "yurume";
+    readonly name: string;
+    readonly defaultEntry: "feed" | "messages";
+  }[];
+  readonly issuer: string;
+  readonly apiBaseUrl: string;
+  readonly activitypubOrigin: string;
+  readonly mediaOrigin: string;
+  readonly socialServerCapabilitiesUrl: string;
+  readonly capabilities: readonly string[];
+  readonly endpoints: {
+    readonly api: string;
+    readonly authProviders: string;
+    readonly currentUser: string;
+    readonly timeline: string;
+    readonly conversations: string;
+    readonly notifications: string;
+    readonly mobilePushRegistrations: string;
+  };
+}
+
+export async function fetchCurrentActor(): Promise<Actor | null> {
+  const res = await apiFetch("/api/auth/me");
+  if (res.status === 401 || res.status === 403) return null;
+  await assertOk(res, "Failed to load current user");
+  const data = (await res.json()) as { actor?: Actor | null };
+  return data.actor ?? null;
+}
+
+export async function fetchSocialServerDiscovery(): Promise<SocialServerDiscovery> {
+  const res = await apiFetch("/.well-known/social-server");
+  await assertOk(res, "Failed to load social server discovery");
+  return (await res.json()) as SocialServerDiscovery;
+}