@commonpub/layer 0.1.0

package/server/api/messages/index.post.ts

@@ -0,0 +1,58 @@
+import { findOrCreateConversation } from '@commonpub/server';
+import { users } from '@commonpub/schema';
+import { and, inArray, isNull } from 'drizzle-orm';
+import { z } from 'zod';
+
+// Accept either UUIDs or usernames — resolve usernames to IDs server-side
+const createConversationBodySchema = z.object({
+  participants: z.array(z.string().min(1)).min(1).max(50),
+});
+
+const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+export default defineEventHandler(async (event) => {
+  const db = useDB();
+  const user = requireAuth(event);
+  const input = await parseBody(event, createConversationBodySchema);
+
+  // Separate UUIDs from usernames, deduplicating each
+  const uuidSet = new Set<string>();
+  const usernameSet = new Set<string>();
+  for (const p of input.participants) {
+    if (UUID_REGEX.test(p)) {
+      uuidSet.add(p);
+    } else {
+      usernameSet.add(p);
+    }
+  }
+
+  const uuids = [...uuidSet];
+  const usernames = [...usernameSet];
+
+  // Resolve usernames to UUIDs (exclude soft-deleted users)
+  if (usernames.length > 0) {
+    const resolved = await db
+      .select({ id: users.id })
+      .from(users)
+      .where(and(inArray(users.username, usernames), isNull(users.deletedAt)));
+
+    if (resolved.length !== usernames.length) {
+      throw createError({ statusCode: 400, statusMessage: 'One or more usernames not found' });
+    }
+    uuids.push(...resolved.map((r) => r.id));
+  }
+
+  // Ensure current user is included
+  if (!uuids.includes(user.id)) {
+    uuids.push(user.id);
+  }
+
+  // Deduplicate (a username could resolve to a UUID already in the list)
+  const participants = [...new Set(uuids)];
+
+  if (participants.length < 2) {
+    throw createError({ statusCode: 400, statusMessage: 'A conversation requires at least one other participant' });
+  }
+
+  return findOrCreateConversation(db, participants);
+});

package/server/api/notifications/[id].delete.ts

@@ -0,0 +1,11 @@
+import { deleteNotification } from '@commonpub/server';
+
+export default defineEventHandler(async (event): Promise<{ success: boolean }> => {
+  const user = requireAuth(event);
+  const db = useDB();
+  const { id } = parseParams(event, { id: 'uuid' });
+
+  await deleteNotification(db, id, user.id);
+
+  return { success: true };
+});

package/server/api/notifications/count.get.ts

@@ -0,0 +1,10 @@
+import { getUnreadCount } from '@commonpub/server';
+
+export default defineEventHandler(async (event): Promise<{ count: number }> => {
+  const user = requireAuth(event);
+  const db = useDB();
+
+  const count = await getUnreadCount(db, user.id);
+
+  return { count };
+});

package/server/api/notifications/index.get.ts

@@ -0,0 +1,24 @@
+import { listNotifications } from '@commonpub/server';
+import type { PaginatedResponse, NotificationItem, NotificationType } from '@commonpub/server';
+import { z } from 'zod';
+
+const notificationsQuerySchema = z.object({
+  type: z.string().max(64).optional(),
+  read: z.enum(['true', 'false']).optional(),
+  limit: z.coerce.number().int().positive().max(100).optional(),
+  offset: z.coerce.number().int().min(0).optional(),
+});
+
+export default defineEventHandler(async (event): Promise<PaginatedResponse<NotificationItem>> => {
+  const user = requireAuth(event);
+  const db = useDB();
+  const query = parseQueryParams(event, notificationsQuerySchema);
+
+  return listNotifications(db, {
+    userId: user.id,
+    type: query.type as NotificationType | undefined,
+    read: query.read !== undefined ? query.read === 'true' : undefined,
+    limit: query.limit,
+    offset: query.offset,
+  });
+});

package/server/api/notifications/read.post.ts

@@ -0,0 +1,15 @@
+import { markNotificationRead, markAllNotificationsRead } from '@commonpub/server';
+
+export default defineEventHandler(async (event): Promise<{ success: boolean }> => {
+  const user = requireAuth(event);
+  const db = useDB();
+  const body = await readBody(event);
+
+  if (body.notificationId) {
+    await markNotificationRead(db, body.notificationId, user.id);
+  } else {
+    await markAllNotificationsRead(db, user.id);
+  }
+
+  return { success: true };
+});

package/server/api/notifications/stream.get.ts

@@ -0,0 +1,59 @@
+import { getUnreadCount } from '@commonpub/server';
+
+export default defineEventHandler(async (event) => {
+  const user = requireAuth(event);
+  const userId = user.id;
+  const db = useDB();
+
+  setResponseHeader(event, 'Content-Type', 'text/event-stream');
+  setResponseHeader(event, 'Cache-Control', 'no-cache');
+  setResponseHeader(event, 'Connection', 'keep-alive');
+
+  const encoder = new TextEncoder();
+  const stream = new ReadableStream({
+    async start(controller) {
+      let closed = false;
+      function cleanup(): void {
+        if (closed) return;
+        closed = true;
+        clearInterval(interval);
+        clearInterval(keepalive);
+        try { controller.close(); } catch { /* already closed */ }
+      }
+
+      // Send initial count
+      const count = await getUnreadCount(db, userId);
+      controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'count', count })}\n\n`));
+
+      // Poll every 10 seconds for new notifications
+      const interval = setInterval(async () => {
+        try {
+          const currentCount = await getUnreadCount(db, userId);
+          controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'count', count: currentCount })}\n\n`));
+        } catch {
+          cleanup();
+        }
+      }, 10000);
+
+      // Send keepalive every 30 seconds
+      const keepalive = setInterval(() => {
+        try {
+          controller.enqueue(encoder.encode(': keepalive\n\n'));
+        } catch {
+          cleanup();
+        }
+      }, 30000);
+
+      // Clean up on close
+      event.node.req.on('close', cleanup);
+    },
+  });
+
+  return new Response(stream, {
+    headers: {
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache',
+      'Connection': 'keep-alive',
+    },
+  });
+});

package/server/api/openapi.get.ts

@@ -0,0 +1,5 @@
+import { generateOpenAPISpec } from '@commonpub/schema';
+
+export default defineEventHandler(() => {
+  return generateOpenAPISpec();
+});

package/server/api/products/[id].delete.ts

@@ -0,0 +1,15 @@
+import { deleteProduct } from '@commonpub/server';
+
+export default defineEventHandler(async (event): Promise<{ deleted: boolean }> => {
+  const db = useDB();
+  requireAdmin(event);
+  const { id } = parseParams(event, { id: 'uuid' });
+
+  const deleted = await deleteProduct(db, id);
+
+  if (!deleted) {
+    throw createError({ statusCode: 404, statusMessage: 'Product not found' });
+  }
+
+  return { deleted: true };
+});

package/server/api/products/[id].put.ts

@@ -0,0 +1,18 @@
+import { updateProduct } from '@commonpub/server';
+import type { ProductDetail } from '@commonpub/server';
+import { updateProductSchema } from '@commonpub/schema';
+
+export default defineEventHandler(async (event): Promise<ProductDetail> => {
+  const db = useDB();
+  const user = requireAuth(event);
+  const { id } = parseParams(event, { id: 'uuid' });
+  const input = await parseBody(event, updateProductSchema);
+
+  const product = await updateProduct(db, id, user.id, input);
+
+  if (!product) {
+    throw createError({ statusCode: 404, statusMessage: 'Product not found' });
+  }
+
+  return product;
+});

package/server/api/products/[slug]/content.get.ts

@@ -0,0 +1,21 @@
+import { getProductBySlug, listProductContent } from '@commonpub/server';
+import { z } from 'zod';
+
+const querySchema = z.object({
+  limit: z.coerce.number().int().positive().max(100).optional(),
+  offset: z.coerce.number().int().min(0).optional(),
+});
+
+export default defineEventHandler(async (event) => {
+  const db = useDB();
+  const { slug } = parseParams(event, { slug: 'string' });
+
+
+  const product = await getProductBySlug(db, slug);
+  if (!product) {
+    throw createError({ statusCode: 404, statusMessage: 'Product not found' });
+  }
+
+  const query = parseQueryParams(event, querySchema);
+  return listProductContent(db, product.id, query);
+});

package/server/api/products/[slug].get.ts

@@ -0,0 +1,16 @@
+import { getProductBySlug } from '@commonpub/server';
+import type { ProductDetail } from '@commonpub/server';
+
+export default defineEventHandler(async (event): Promise<ProductDetail> => {
+  const db = useDB();
+  const { slug } = parseParams(event, { slug: 'string' });
+
+
+  const product = await getProductBySlug(db, slug);
+
+  if (!product) {
+    throw createError({ statusCode: 404, statusMessage: 'Product not found' });
+  }
+
+  return product;
+});

package/server/api/products/index.get.ts

@@ -0,0 +1,28 @@
+import { searchProducts } from '@commonpub/server';
+import type { PaginatedResponse, ProductListItem } from '@commonpub/server';
+import { productStatusSchema, productCategorySchema } from '@commonpub/schema';
+import { z } from 'zod';
+
+const productSearchSchema = z.object({
+  q: z.string().max(200).optional(),
+  search: z.string().max(200).optional(),
+  category: productCategorySchema.optional(),
+  status: productStatusSchema.optional(),
+  hubId: z.string().uuid().optional(),
+  limit: z.coerce.number().int().positive().max(100).optional(),
+  offset: z.coerce.number().int().min(0).optional(),
+});
+
+export default defineEventHandler(async (event): Promise<PaginatedResponse<ProductListItem>> => {
+  const db = useDB();
+  const query = parseQueryParams(event, productSearchSchema);
+
+  return searchProducts(db, {
+    search: query.q ?? query.search,
+    category: query.category,
+    status: query.status,
+    hubId: query.hubId,
+    limit: query.limit,
+    offset: query.offset,
+  });
+});

package/server/api/profile.get.ts

@@ -0,0 +1,15 @@
+import { getUserByUsername } from '@commonpub/server';
+import type { UserProfile } from '@commonpub/server';
+
+export default defineEventHandler(async (event): Promise<UserProfile> => {
+  const db = useDB();
+  const user = requireAuth(event);
+
+  const profile = await getUserByUsername(db, user.username);
+
+  if (!profile) {
+    throw createError({ statusCode: 404, statusMessage: 'Profile not found' });
+  }
+
+  return profile;
+});

package/server/api/profile.put.ts

@@ -0,0 +1,24 @@
+import { updateUserProfile } from '@commonpub/server';
+import type { UserProfile } from '@commonpub/server';
+import { updateProfileSchema } from '@commonpub/schema';
+
+export default defineEventHandler(async (event): Promise<UserProfile> => {
+  const db = useDB();
+  const user = requireAuth(event);
+  const raw = await parseBody(event, updateProfileSchema);
+  // Convert empty strings to undefined for URL fields (avoids <img src="">)
+  const input = {
+    ...raw,
+    avatarUrl: raw.avatarUrl || undefined,
+    bannerUrl: raw.bannerUrl || undefined,
+    website: raw.website || undefined,
+  };
+
+  const profile = await updateUserProfile(db, user.id, input);
+
+  if (!profile) {
+    throw createError({ statusCode: 404, statusMessage: 'Profile not found' });
+  }
+
+  return profile;
+});

package/server/api/resolve-identity.post.ts

@@ -0,0 +1,34 @@
+import { eq, and, isNull } from 'drizzle-orm';
+import { users } from '@commonpub/schema';
+
+/**
+ * Resolve identity (username or email) to an email address.
+ * The client then uses the resolved email to call Better Auth's sign-in directly.
+ */
+export default defineEventHandler(async (event) => {
+  const body = await readBody(event);
+  const { identity } = body as { identity: string };
+
+  if (!identity) {
+    throw createError({ statusCode: 400, statusMessage: 'Username or email required' });
+  }
+
+  // If it looks like an email, return it directly
+  if (identity.includes('@')) {
+    return { email: identity };
+  }
+
+  // Otherwise resolve username to email
+  const db = useDB();
+  const [user] = await db
+    .select({ email: users.email })
+    .from(users)
+    .where(and(eq(users.username, identity), isNull(users.deletedAt)))
+    .limit(1);
+
+  if (!user) {
+    throw createError({ statusCode: 401, statusMessage: 'Invalid credentials' });
+  }
+
+  return { email: user.email };
+});

package/server/api/search/index.get.ts

@@ -0,0 +1,24 @@
+import { listContent } from '@commonpub/server';
+import type { PaginatedResponse, ContentListItem } from '@commonpub/server';
+import { contentFiltersSchema } from '@commonpub/schema';
+import { z } from 'zod';
+
+const searchQuerySchema = contentFiltersSchema.extend({
+  q: z.string().max(200).optional(),
+});
+
+export default defineEventHandler(async (event): Promise<PaginatedResponse<ContentListItem>> => {
+  const db = useDB();
+  const filters = parseQueryParams(event, searchQuerySchema);
+  const q = filters.q || filters.search;
+
+  if (!q) {
+    return { items: [], total: 0 };
+  }
+
+  return listContent(db, {
+    ...filters,
+    status: 'published',
+    search: q,
+  });
+});

package/server/api/search/trending.get.ts

@@ -0,0 +1,22 @@
+import { sql } from 'drizzle-orm';
+import { contentItems } from '@commonpub/schema';
+
+export default defineEventHandler(async (): Promise<Array<{ query: string; trend: number }>> => {
+  const db = useDB();
+
+  // Return the most-viewed content titles as "trending searches"
+  const rows = await db
+    .select({
+      title: contentItems.title,
+      viewCount: contentItems.viewCount,
+    })
+    .from(contentItems)
+    .where(sql`${contentItems.status} = 'published'`)
+    .orderBy(sql`${contentItems.viewCount} DESC`)
+    .limit(8);
+
+  return rows.map((r) => ({
+    query: r.title,
+    trend: r.viewCount,
+  }));
+});

package/server/api/social/bookmark.get.ts

@@ -0,0 +1,16 @@
+import { isBookmarked } from '@commonpub/server';
+import { z } from 'zod';
+
+const checkSchema = z.object({
+  targetType: z.enum(['project', 'article', 'blog', 'explainer', 'learning_path']),
+  targetId: z.string().uuid(),
+});
+
+export default defineEventHandler(async (event): Promise<{ bookmarked: boolean }> => {
+  const user = requireAuth(event);
+  const db = useDB();
+  const query = parseQueryParams(event, checkSchema);
+
+  const bookmarked = await isBookmarked(db, user.id, query.targetType, query.targetId);
+  return { bookmarked };
+});

package/server/api/social/bookmark.post.ts

@@ -0,0 +1,15 @@
+import { toggleBookmark } from '@commonpub/server';
+import { z } from 'zod';
+
+const toggleBookmarkSchema = z.object({
+  targetType: z.enum(['project', 'article', 'blog', 'explainer', 'learning_path']),
+  targetId: z.string().uuid(),
+});
+
+export default defineEventHandler(async (event): Promise<{ bookmarked: boolean }> => {
+  const user = requireAuth(event);
+  const db = useDB();
+  const input = await parseBody(event, toggleBookmarkSchema);
+
+  return toggleBookmark(db, user.id, input.targetType, input.targetId);
+});

package/server/api/social/bookmarks.get.ts

@@ -0,0 +1,16 @@
+import { listUserBookmarks } from '@commonpub/server';
+import type { PaginatedResponse, BookmarkItem } from '@commonpub/server';
+import { z } from 'zod';
+
+const bookmarksQuerySchema = z.object({
+  limit: z.coerce.number().int().positive().max(100).optional(),
+  offset: z.coerce.number().int().min(0).optional(),
+});
+
+export default defineEventHandler(async (event): Promise<PaginatedResponse<BookmarkItem>> => {
+  const user = requireAuth(event);
+  const db = useDB();
+  const query = parseQueryParams(event, bookmarksQuerySchema);
+
+  return listUserBookmarks(db, user.id, query);
+});

package/server/api/social/comments/[id].delete.ts

@@ -0,0 +1,13 @@
+import { deleteComment } from '@commonpub/server';
+
+export default defineEventHandler(async (event): Promise<{ success: boolean }> => {
+  const user = requireAuth(event);
+  const db = useDB();
+  const { id } = parseParams(event, { id: 'uuid' });
+
+  const deleted = await deleteComment(db, id, user.id);
+  if (!deleted) {
+    throw createError({ statusCode: 404, statusMessage: 'Comment not found or not owned by you' });
+  }
+  return { success: true };
+});

package/server/api/social/comments.get.ts

@@ -0,0 +1,18 @@
+import { listComments } from '@commonpub/server';
+import type { CommentItem } from '@commonpub/server';
+import { commentTargetTypeSchema } from '@commonpub/schema';
+import { z } from 'zod';
+
+const commentsQuerySchema = z.object({
+  targetType: commentTargetTypeSchema,
+  targetId: z.string().uuid(),
+  limit: z.coerce.number().int().min(1).max(100).optional().default(20),
+  offset: z.coerce.number().int().min(0).optional().default(0),
+});
+
+export default defineEventHandler(async (event): Promise<CommentItem[]> => {
+  const db = useDB();
+  const query = parseQueryParams(event, commentsQuerySchema);
+
+  return listComments(db, query.targetType, query.targetId, query.limit, query.offset);
+});

package/server/api/social/comments.post.ts

@@ -0,0 +1,11 @@
+import { createComment } from '@commonpub/server';
+import type { CommentItem } from '@commonpub/server';
+import { createCommentSchema } from '@commonpub/schema';
+
+export default defineEventHandler(async (event): Promise<CommentItem> => {
+  const user = requireAuth(event);
+  const db = useDB();
+  const input = await parseBody(event, createCommentSchema);
+
+  return createComment(db, user.id, input);
+});

package/server/api/social/like.get.ts

@@ -0,0 +1,17 @@
+import { isLiked } from '@commonpub/server';
+import { likeTargetTypeSchema } from '@commonpub/schema';
+import { z } from 'zod';
+
+const likeQuerySchema = z.object({
+  targetType: likeTargetTypeSchema,
+  targetId: z.string().uuid(),
+});
+
+export default defineEventHandler(async (event): Promise<{ liked: boolean }> => {
+  const user = requireAuth(event);
+  const db = useDB();
+  const query = parseQueryParams(event, likeQuerySchema);
+
+  const liked = await isLiked(db, user.id, query.targetType, query.targetId);
+  return { liked };
+});

package/server/api/social/like.post.ts

@@ -0,0 +1,35 @@
+import { toggleLike, onContentLiked, onContentUnliked, getContentSlugById, buildContentUri } from '@commonpub/server';
+import { likeTargetTypeSchema } from '@commonpub/schema';
+import { z } from 'zod';
+
+const toggleLikeSchema = z.object({
+  targetType: likeTargetTypeSchema,
+  targetId: z.string().uuid(),
+});
+
+/** Content types that should federate likes (not posts or comments) */
+const FEDERABLE_LIKE_TYPES = new Set(['project', 'article', 'blog', 'explainer']);
+
+export default defineEventHandler(async (event): Promise<{ liked: boolean }> => {
+  const user = requireAuth(event);
+  const db = useDB();
+  const config = useConfig();
+  const input = await parseBody(event, toggleLikeSchema);
+
+  const result = await toggleLike(db, user.id, input.targetType, input.targetId);
+
+  // Federate likes on content items (not posts/comments)
+  if (FEDERABLE_LIKE_TYPES.has(input.targetType)) {
+    const slug = await getContentSlugById(db, input.targetId);
+    if (slug) {
+      const contentUri = buildContentUri(config.instance.domain, slug);
+      if (result.liked) {
+        await onContentLiked(db, user.id, contentUri, config);
+      } else {
+        await onContentUnliked(db, user.id, contentUri, config);
+      }
+    }
+  }
+
+  return result;
+});

package/server/api/stats.get.ts

@@ -0,0 +1,8 @@
+import { getPlatformStats } from '@commonpub/server';
+import type { PlatformStats } from '@commonpub/server';
+
+export default defineEventHandler(async (_event): Promise<PlatformStats> => {
+  const db = useDB();
+  const stats = await getPlatformStats(db);
+  return stats;
+});

package/server/api/user/hubs.get.ts

@@ -0,0 +1,22 @@
+import { eq } from 'drizzle-orm';
+import { hubs, hubMembers } from '@commonpub/schema';
+
+/** GET /api/user/hubs — List hubs the current user is a member of */
+export default defineEventHandler(async (event) => {
+  const user = requireAuth(event);
+  const db = useDB();
+
+  const rows = await db
+    .select({
+      id: hubs.id,
+      name: hubs.name,
+      slug: hubs.slug,
+      iconUrl: hubs.iconUrl,
+      role: hubMembers.role,
+    })
+    .from(hubMembers)
+    .innerJoin(hubs, eq(hubMembers.hubId, hubs.id))
+    .where(eq(hubMembers.userId, user.id));
+
+  return { items: rows };
+});

package/server/api/users/[username]/content.get.ts

@@ -0,0 +1,21 @@
+import { getUserByUsername, getUserContent } from '@commonpub/server';
+import type { PaginatedResponse, ContentListItem } from '@commonpub/server';
+import { contentTypeSchema } from '@commonpub/schema';
+import { z } from 'zod';
+
+const userContentQuerySchema = z.object({
+  type: contentTypeSchema.optional(),
+});
+
+export default defineEventHandler(async (event): Promise<PaginatedResponse<ContentListItem>> => {
+  const db = useDB();
+  const { username } = parseParams(event, { username: 'string' });
+  const query = parseQueryParams(event, userContentQuerySchema);
+
+  const user = await getUserByUsername(db, username);
+  if (!user) {
+    throw createError({ statusCode: 404, statusMessage: 'User not found' });
+  }
+
+  return getUserContent(db, user.id, query.type);
+});