feat: Implement core API endpoints, database schema, ActivityPub federation, and initial user interface for the application.

2026-01-22 02:44:46 -08:00
parent 537fc5e8c2
commit b76e586bbc
62 changed files with 9447 additions and 115 deletions
@@ -0,0 +1,191 @@
+import { NextResponse } from 'next/server';
+import { db, follows, users, notifications } from '@/db';
+import { eq, and } from 'drizzle-orm';
+import { requireAuth } from '@/lib/auth';
+
+type RouteContext = { params: Promise<{ handle: string }> };
+
+// Check follow status
+export async function GET(request: Request, context: RouteContext) {
+    try {
+        const currentUser = await requireAuth();
+        const { handle } = await context.params;
+        const cleanHandle = handle.toLowerCase().replace(/^@/, '');
+
+        if (currentUser.isSuspended || currentUser.isSilenced) {
+            return NextResponse.json({ error: 'Account restricted' }, { status: 403 });
+        }
+
+        if (!db) {
+            return NextResponse.json({ error: 'Database not available' }, { status: 503 });
+        }
+
+        const targetUser = await db.query.users.findFirst({
+            where: eq(users.handle, cleanHandle),
+        });
+
+        if (!targetUser) {
+            return NextResponse.json({ error: 'User not found' }, { status: 404 });
+        }
+        if (targetUser.isSuspended) {
+            return NextResponse.json({ error: 'User not found' }, { status: 404 });
+        }
+
+        if (targetUser.id === currentUser.id) {
+            return NextResponse.json({ following: false, self: true });
+        }
+
+        const existingFollow = await db.query.follows.findFirst({
+            where: and(
+                eq(follows.followerId, currentUser.id),
+                eq(follows.followingId, targetUser.id)
+            ),
+        });
+
+        return NextResponse.json({ following: !!existingFollow });
+    } catch (error) {
+        if (error instanceof Error && error.message === 'Authentication required') {
+            return NextResponse.json({ error: 'Authentication required' }, { status: 401 });
+        }
+        console.error('Follow status error:', error);
+        return NextResponse.json({ error: 'Failed to get follow status' }, { status: 500 });
+    }
+}
+
+// Follow a user
+export async function POST(request: Request, context: RouteContext) {
+    try {
+        const currentUser = await requireAuth();
+        const { handle } = await context.params;
+        const cleanHandle = handle.toLowerCase().replace(/^@/, '');
+
+        if (currentUser.isSuspended || currentUser.isSilenced) {
+            return NextResponse.json({ error: 'Account restricted' }, { status: 403 });
+        }
+
+        if (!db) {
+            return NextResponse.json({ error: 'Database not available' }, { status: 503 });
+        }
+
+        // Find target user
+        const targetUser = await db.query.users.findFirst({
+            where: eq(users.handle, cleanHandle),
+        });
+
+        if (!targetUser) {
+            return NextResponse.json({ error: 'User not found' }, { status: 404 });
+        }
+        if (targetUser.isSuspended) {
+            return NextResponse.json({ error: 'User not found' }, { status: 404 });
+        }
+
+        // Can't follow yourself
+        if (targetUser.id === currentUser.id) {
+            return NextResponse.json({ error: 'Cannot follow yourself' }, { status: 400 });
+        }
+
+        // Check if already following
+        const existingFollow = await db.query.follows.findFirst({
+            where: and(
+                eq(follows.followerId, currentUser.id),
+                eq(follows.followingId, targetUser.id)
+            ),
+        });
+
+        if (existingFollow) {
+            return NextResponse.json({ error: 'Already following' }, { status: 400 });
+        }
+
+        // Create follow
+        await db.insert(follows).values({
+            followerId: currentUser.id,
+            followingId: targetUser.id,
+        });
+
+        if (currentUser.id !== targetUser.id) {
+            await db.insert(notifications).values({
+                userId: targetUser.id,
+                actorId: currentUser.id,
+                type: 'follow',
+            });
+        }
+
+        // Update counts
+        await db.update(users)
+            .set({ followingCount: currentUser.followingCount + 1 })
+            .where(eq(users.id, currentUser.id));
+
+        await db.update(users)
+            .set({ followersCount: targetUser.followersCount + 1 })
+            .where(eq(users.id, targetUser.id));
+
+        // TODO: Send ActivityPub Follow activity
+
+        return NextResponse.json({ success: true, following: true });
+    } catch (error) {
+        if (error instanceof Error && error.message === 'Authentication required') {
+            return NextResponse.json({ error: 'Authentication required' }, { status: 401 });
+        }
+        console.error('Follow error:', error);
+        return NextResponse.json({ error: 'Failed to follow' }, { status: 500 });
+    }
+}
+
+// Unfollow a user
+export async function DELETE(request: Request, context: RouteContext) {
+    try {
+        const currentUser = await requireAuth();
+        const { handle } = await context.params;
+        const cleanHandle = handle.toLowerCase().replace(/^@/, '');
+
+        if (!db) {
+            return NextResponse.json({ error: 'Database not available' }, { status: 503 });
+        }
+
+        // Find target user
+        const targetUser = await db.query.users.findFirst({
+            where: eq(users.handle, cleanHandle),
+        });
+
+        if (!targetUser) {
+            return NextResponse.json({ error: 'User not found' }, { status: 404 });
+        }
+        if (targetUser.isSuspended) {
+            return NextResponse.json({ error: 'User not found' }, { status: 404 });
+        }
+
+        // Find existing follow
+        const existingFollow = await db.query.follows.findFirst({
+            where: and(
+                eq(follows.followerId, currentUser.id),
+                eq(follows.followingId, targetUser.id)
+            ),
+        });
+
+        if (!existingFollow) {
+            return NextResponse.json({ error: 'Not following' }, { status: 400 });
+        }
+
+        // Remove follow
+        await db.delete(follows).where(eq(follows.id, existingFollow.id));
+
+        // Update counts
+        await db.update(users)
+            .set({ followingCount: Math.max(0, currentUser.followingCount - 1) })
+            .where(eq(users.id, currentUser.id));
+
+        await db.update(users)
+            .set({ followersCount: Math.max(0, targetUser.followersCount - 1) })
+            .where(eq(users.id, targetUser.id));
+
+        // TODO: Send ActivityPub Undo Follow activity
+
+        return NextResponse.json({ success: true, following: false });
+    } catch (error) {
+        if (error instanceof Error && error.message === 'Authentication required') {
+            return NextResponse.json({ error: 'Authentication required' }, { status: 401 });
+        }
+        console.error('Unfollow error:', error);
+        return NextResponse.json({ error: 'Failed to unfollow' }, { status: 500 });
+    }
+}
@@ -0,0 +1,54 @@
+import { NextResponse } from 'next/server';
+import { db, follows, users } from '@/db';
+import { eq } from 'drizzle-orm';
+
+type RouteContext = { params: Promise<{ handle: string }> };
+
+export async function GET(request: Request, context: RouteContext) {
+    try {
+        const { handle } = await context.params;
+        const cleanHandle = handle.toLowerCase().replace(/^@/, '');
+        const { searchParams } = new URL(request.url);
+        const limit = Math.min(parseInt(searchParams.get('limit') || '20'), 50);
+
+        // Return empty if no database
+        if (!db) {
+            return NextResponse.json({ followers: [], nextCursor: null });
+        }
+
+        // Find the user
+        const user = await db.query.users.findFirst({
+            where: eq(users.handle, cleanHandle),
+        });
+
+        if (!user) {
+            return NextResponse.json({ error: 'User not found' }, { status: 404 });
+        }
+        if (user.isSuspended) {
+            return NextResponse.json({ error: 'User not found' }, { status: 404 });
+        }
+
+        // Get followers
+        const userFollowers = await db.query.follows.findMany({
+            where: eq(follows.followingId, user.id),
+            with: {
+                follower: true,
+            },
+            limit,
+        });
+
+        return NextResponse.json({
+            followers: userFollowers.map(f => ({
+                id: f.follower.id,
+                handle: f.follower.handle,
+                displayName: f.follower.displayName,
+                avatarUrl: f.follower.avatarUrl,
+                bio: f.follower.bio,
+            })),
+            nextCursor: userFollowers.length === limit ? userFollowers[userFollowers.length - 1]?.id : null,
+        });
+    } catch (error) {
+        console.error('Get followers error:', error);
+        return NextResponse.json({ error: 'Failed to get followers' }, { status: 500 });
+    }
+}
@@ -0,0 +1,54 @@
+import { NextResponse } from 'next/server';
+import { db, follows, users } from '@/db';
+import { eq } from 'drizzle-orm';
+
+type RouteContext = { params: Promise<{ handle: string }> };
+
+export async function GET(request: Request, context: RouteContext) {
+    try {
+        const { handle } = await context.params;
+        const cleanHandle = handle.toLowerCase().replace(/^@/, '');
+        const { searchParams } = new URL(request.url);
+        const limit = Math.min(parseInt(searchParams.get('limit') || '20'), 50);
+
+        // Return empty if no database
+        if (!db) {
+            return NextResponse.json({ following: [], nextCursor: null });
+        }
+
+        // Find the user
+        const user = await db.query.users.findFirst({
+            where: eq(users.handle, cleanHandle),
+        });
+
+        if (!user) {
+            return NextResponse.json({ error: 'User not found' }, { status: 404 });
+        }
+        if (user.isSuspended) {
+            return NextResponse.json({ error: 'User not found' }, { status: 404 });
+        }
+
+        // Get following
+        const userFollowing = await db.query.follows.findMany({
+            where: eq(follows.followerId, user.id),
+            with: {
+                following: true,
+            },
+            limit,
+        });
+
+        return NextResponse.json({
+            following: userFollowing.map(f => ({
+                id: f.following.id,
+                handle: f.following.handle,
+                displayName: f.following.displayName,
+                avatarUrl: f.following.avatarUrl,
+                bio: f.following.bio,
+            })),
+            nextCursor: userFollowing.length === limit ? userFollowing[userFollowing.length - 1]?.id : null,
+        });
+    } catch (error) {
+        console.error('Get following error:', error);
+        return NextResponse.json({ error: 'Failed to get following' }, { status: 500 });
+    }
+}
@@ -0,0 +1,53 @@
+import { NextResponse } from 'next/server';
+import { db, posts, users } from '@/db';
+import { eq, desc, and } from 'drizzle-orm';
+
+type RouteContext = { params: Promise<{ handle: string }> };
+
+export async function GET(request: Request, context: RouteContext) {
+    try {
+        const { handle } = await context.params;
+        const cleanHandle = handle.toLowerCase().replace(/^@/, '');
+        const { searchParams } = new URL(request.url);
+        const limit = Math.min(parseInt(searchParams.get('limit') || '20'), 50);
+
+        // Return empty if no database
+        if (!db) {
+            return NextResponse.json({ posts: [], nextCursor: null });
+        }
+
+        // Find the user
+        const user = await db.query.users.findFirst({
+            where: eq(users.handle, cleanHandle),
+        });
+
+        if (!user) {
+            return NextResponse.json({ error: 'User not found' }, { status: 404 });
+        }
+        if (user.isSuspended) {
+            return NextResponse.json({ error: 'User not found' }, { status: 404 });
+        }
+
+        // Get user's posts
+        const userPosts = await db.query.posts.findMany({
+            where: and(eq(posts.userId, user.id), eq(posts.isRemoved, false)),
+            with: {
+                author: true,
+                media: true,
+                replyTo: {
+                    with: { author: true },
+                },
+            },
+            orderBy: [desc(posts.createdAt)],
+            limit,
+        });
+
+        return NextResponse.json({
+            posts: userPosts,
+            nextCursor: userPosts.length === limit ? userPosts[userPosts.length - 1]?.id : null,
+        });
+    } catch (error) {
+        console.error('Get user posts error:', error);
+        return NextResponse.json({ error: 'Failed to get posts' }, { status: 500 });
+    }
+}
@@ -0,0 +1,73 @@
+import { NextResponse } from 'next/server';
+import { db, users } from '@/db';
+import { eq } from 'drizzle-orm';
+import { userToActor } from '@/lib/activitypub/actor';
+
+type RouteContext = { params: Promise<{ handle: string }> };
+
+export async function GET(request: Request, context: RouteContext) {
+    try {
+        const { handle } = await context.params;
+        const cleanHandle = handle.toLowerCase().replace(/^@/, '');
+
+        // Return mock user if no database
+        if (!db) {
+            return NextResponse.json({
+                user: {
+                    id: 'demo-user',
+                    handle: cleanHandle,
+                    displayName: cleanHandle,
+                    bio: 'This is a demo profile.',
+                    avatarUrl: null,
+                    headerUrl: null,
+                    followersCount: 0,
+                    followingCount: 0,
+                    postsCount: 0,
+                    createdAt: new Date().toISOString(),
+                }
+            });
+        }
+
+        const user = await db.query.users.findFirst({
+            where: eq(users.handle, cleanHandle),
+        });
+
+        if (!user) {
+            return NextResponse.json({ error: 'User not found' }, { status: 404 });
+        }
+        if (user.isSuspended) {
+            return NextResponse.json({ error: 'User not found' }, { status: 404 });
+        }
+
+        // Check if ActivityPub request
+        const accept = request.headers.get('accept') || '';
+        if (accept.includes('application/activity+json') || accept.includes('application/ld+json')) {
+            const nodeDomain = process.env.NEXT_PUBLIC_NODE_DOMAIN || 'localhost:3000';
+            const actor = userToActor(user, nodeDomain);
+            return NextResponse.json(actor, {
+                headers: {
+                    'Content-Type': 'application/activity+json',
+                },
+            });
+        }
+
+        // Return user profile (without sensitive data)
+        return NextResponse.json({
+            user: {
+                id: user.id,
+                handle: user.handle,
+                displayName: user.displayName,
+                bio: user.bio,
+                avatarUrl: user.avatarUrl,
+                headerUrl: user.headerUrl,
+                followersCount: user.followersCount,
+                followingCount: user.followingCount,
+                postsCount: user.postsCount,
+                createdAt: user.createdAt,
+            }
+        });
+    } catch (error) {
+        console.error('Get user error:', error);
+        return NextResponse.json({ error: 'Failed to get user' }, { status: 500 });
+    }
+}