@commonpub/layer 0.1.0

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

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

package/server/api/contests/[slug]/entries.get.ts

@@ -0,0 +1,18 @@
+import { listContestEntries, getContestBySlug } from '@commonpub/server';
+import type { ContestEntryItem } from '@commonpub/server';
+import { z } from 'zod';
+
+const entriesQuerySchema = z.object({
+  limit: z.coerce.number().int().min(1).max(100).optional(),
+  offset: z.coerce.number().int().min(0).optional(),
+});
+
+export default defineEventHandler(async (event): Promise<{ items: ContestEntryItem[]; total: number }> => {
+  requireFeature('contests');
+  const db = useDB();
+  const { slug } = parseParams(event, { slug: 'string' });
+  const query = parseQueryParams(event, entriesQuerySchema);
+  const contest = await getContestBySlug(db, slug);
+  if (!contest) throw createError({ statusCode: 404, statusMessage: 'Contest not found' });
+  return listContestEntries(db, contest.id, query);
+});

package/server/api/contests/[slug]/entries.post.ts

@@ -0,0 +1,23 @@
+import { submitContestEntry, getContestBySlug } from '@commonpub/server';
+import type { ContestEntryItem } from '@commonpub/server';
+import { z } from 'zod';
+
+const submitEntrySchema = z.object({
+  contentId: z.string().uuid(),
+});
+
+export default defineEventHandler(async (event): Promise<ContestEntryItem> => {
+  requireFeature('contests');
+  const user = requireAuth(event);
+  const db = useDB();
+  const { slug } = parseParams(event, { slug: 'string' });
+  const contest = await getContestBySlug(db, slug);
+  if (!contest) throw createError({ statusCode: 404, statusMessage: 'Contest not found' });
+  const input = await parseBody(event, submitEntrySchema);
+
+  const entry = await submitContestEntry(db, contest.id, input.contentId, user.id);
+  if (!entry) {
+    throw createError({ statusCode: 400, statusMessage: 'Cannot submit entry. Contest may not be active, or content is not published or not owned by you.' });
+  }
+  return entry;
+});

package/server/api/contests/[slug]/index.delete.ts

@@ -0,0 +1,21 @@
+import { getContestBySlug, deleteContest } from '@commonpub/server';
+
+export default defineEventHandler(async (event): Promise<{ deleted: boolean }> => {
+  requireFeature('contests');
+  const db = useDB();
+  const user = requireAuth(event);
+  const { slug } = parseParams(event, { slug: 'string' });
+
+
+  const contest = await getContestBySlug(db, slug);
+  if (!contest) {
+    throw createError({ statusCode: 404, statusMessage: 'Contest not found' });
+  }
+
+  const deleted = await deleteContest(db, contest.id, user.id);
+  if (!deleted) {
+    throw createError({ statusCode: 403, statusMessage: 'Not authorized to delete this contest' });
+  }
+
+  return { deleted: true };
+});

package/server/api/contests/[slug]/index.get.ts

@@ -0,0 +1,11 @@
+import { getContestBySlug } from '@commonpub/server';
+import type { ContestDetail } from '@commonpub/server';
+
+export default defineEventHandler(async (event): Promise<ContestDetail> => {
+  requireFeature('contests');
+  const db = useDB();
+  const { slug } = parseParams(event, { slug: 'string' });
+  const contest = await getContestBySlug(db, slug);
+  if (!contest) throw createError({ statusCode: 404, statusMessage: 'Contest not found' });
+  return contest;
+});

package/server/api/contests/[slug]/index.put.ts

@@ -0,0 +1,15 @@
+import { updateContest } from '@commonpub/server';
+import type { ContestDetail } from '@commonpub/server';
+import { updateContestSchema } from '@commonpub/schema';
+
+export default defineEventHandler(async (event): Promise<ContestDetail> => {
+  requireFeature('contests');
+  const user = requireAuth(event);
+  const db = useDB();
+  const { slug } = parseParams(event, { slug: 'string' });
+  const input = await parseBody(event, updateContestSchema);
+
+  const result = await updateContest(db, slug, user.id, input);
+  if (!result) throw createError({ statusCode: 403, statusMessage: 'Not authorized or contest not found' });
+  return result;
+});

package/server/api/contests/[slug]/judge.post.ts

@@ -0,0 +1,12 @@
+import { judgeContestEntry } from '@commonpub/server';
+import { judgeEntrySchema } from '@commonpub/schema';
+
+export default defineEventHandler(async (event): Promise<{ success: boolean }> => {
+  requireFeature('contests');
+  const user = requireAuth(event);
+  const db = useDB();
+  const input = await parseBody(event, judgeEntrySchema);
+
+  await judgeContestEntry(db, input.entryId, input.score, user.id);
+  return { success: true };
+});

package/server/api/contests/[slug]/transition.post.ts

@@ -0,0 +1,24 @@
+import { getContestBySlug, transitionContestStatus } from '@commonpub/server';
+import type { ContestStatus } from '@commonpub/server';
+import { contestTransitionSchema } from '@commonpub/schema';
+
+export default defineEventHandler(async (event): Promise<{ transitioned: boolean; newStatus: ContestStatus }> => {
+  requireFeature('contests');
+  const db = useDB();
+  const user = requireAuth(event);
+  const { slug } = parseParams(event, { slug: 'string' });
+  const input = await parseBody(event, contestTransitionSchema);
+
+  const contest = await getContestBySlug(db, slug);
+  if (!contest) {
+    throw createError({ statusCode: 404, statusMessage: 'Contest not found' });
+  }
+
+  const result = await transitionContestStatus(db, contest.id, user.id, input.status);
+
+  if (!result.transitioned) {
+    throw createError({ statusCode: 400, statusMessage: result.error || 'Transition failed' });
+  }
+
+  return { transitioned: true, newStatus: input.status };
+});

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

@@ -0,0 +1,10 @@
+import { listContests } from '@commonpub/server';
+import type { PaginatedResponse, ContestListItem } from '@commonpub/server';
+import { contestFiltersSchema } from '@commonpub/schema';
+
+export default defineEventHandler(async (event): Promise<PaginatedResponse<ContestListItem>> => {
+  requireFeature('contests');
+  const db = useDB();
+  const filters = parseQueryParams(event, contestFiltersSchema);
+  return listContests(db, filters);
+});

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

@@ -0,0 +1,28 @@
+import { createContest } from '@commonpub/server';
+import type { ContestDetail, CreateContestInput } from '@commonpub/server';
+import { createContestSchema } from '@commonpub/schema';
+
+function slugify(text: string): string {
+  return text
+    .toLowerCase()
+    .replace(/[^\w\s-]/g, '')
+    .replace(/\s+/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-|-$/g, '')
+    .slice(0, 128);
+}
+
+export default defineEventHandler(async (event): Promise<ContestDetail> => {
+  requireFeature('contests');
+  const user = requireAuth(event);
+  const db = useDB();
+  const config = useConfig();
+  const input = await parseBody(event, createContestSchema);
+
+  const slug = slugify(input.title) || `contest-${Date.now()}`;
+
+  return createContest(db, { ...input, slug, createdBy: user.id } as CreateContestInput, {
+    userRole: user.role,
+    contestCreationPolicy: config.instance.contestCreation ?? 'staff',
+  });
+});

package/server/api/docs/[siteSlug]/index.delete.ts

@@ -0,0 +1,14 @@
+import { getDocsSiteBySlug, deleteDocsSite } from '@commonpub/server';
+
+export default defineEventHandler(async (event) => {
+  const user = requireAuth(event);
+  const db = useDB();
+  const { siteSlug } = parseParams(event, { siteSlug: 'string' });
+
+  const result = await getDocsSiteBySlug(db, siteSlug);
+  if (!result) {
+    throw createError({ statusCode: 404, statusMessage: 'Docs site not found' });
+  }
+
+  return deleteDocsSite(db, result.site.id, user.id);
+});

package/server/api/docs/[siteSlug]/index.get.ts

@@ -0,0 +1,17 @@
+import { getDocsSiteBySlug } from '@commonpub/server';
+
+export default defineEventHandler(async (event) => {
+  const db = useDB();
+  const { siteSlug } = parseParams(event, { siteSlug: 'string' });
+
+  const result = await getDocsSiteBySlug(db, siteSlug);
+  if (!result) {
+    throw createError({ statusCode: 404, statusMessage: 'Docs site not found' });
+  }
+
+  // Flatten the nested { site, versions } shape so frontend can use site.name directly
+  return {
+    ...result.site,
+    versions: result.versions,
+  };
+});

package/server/api/docs/[siteSlug]/index.put.ts

@@ -0,0 +1,20 @@
+import { getDocsSiteBySlug, updateDocsSite } from '@commonpub/server';
+import { updateDocsSiteSchema } from '@commonpub/schema';
+
+export default defineEventHandler(async (event) => {
+  const user = requireAuth(event);
+  const db = useDB();
+  const { siteSlug } = parseParams(event, { siteSlug: 'string' });
+  const input = await parseBody(event, updateDocsSiteSchema);
+
+  const result = await getDocsSiteBySlug(db, siteSlug);
+  if (!result) {
+    throw createError({ statusCode: 404, statusMessage: 'Docs site not found' });
+  }
+
+  const updated = await updateDocsSite(db, result.site.id, user.id, input);
+  if (!updated) {
+    throw createError({ statusCode: 403, statusMessage: 'Not authorized to update this docs site' });
+  }
+  return updated;
+});

package/server/api/docs/[siteSlug]/nav.get.ts

@@ -0,0 +1,26 @@
+import { getDocsSiteBySlug, listDocsPages } from '@commonpub/server';
+import { z } from 'zod';
+
+const navQuerySchema = z.object({
+  version: z.string().max(32).optional(),
+});
+
+export default defineEventHandler(async (event) => {
+  const db = useDB();
+  const { siteSlug } = parseParams(event, { siteSlug: 'string' });
+  const query = parseQueryParams(event, navQuerySchema);
+
+  const result = await getDocsSiteBySlug(db, siteSlug);
+  if (!result) throw createError({ statusCode: 404, statusMessage: 'Docs site not found' });
+
+  // Find the requested or default version
+  const version = query.version
+    ? result.versions?.find((v) => v.version === query.version)
+    : result.versions?.find((v) => v.isDefault) ?? result.versions?.[0];
+
+  if (!version) return [];
+
+  // Return pages directly as nav items
+  const pages = await listDocsPages(db, version.id);
+  return pages.map(p => ({ id: p.id, title: p.title, slug: p.slug, sortOrder: p.sortOrder, parentId: p.parentId }));
+});

package/server/api/docs/[siteSlug]/pages/[pageId].delete.ts

@@ -0,0 +1,14 @@
+import { deleteDocsPage } from '@commonpub/server';
+
+export default defineEventHandler(async (event) => {
+  const user = requireAuth(event);
+  const db = useDB();
+  const { pageId } = parseParams(event, { pageId: 'uuid' });
+
+  const result = await deleteDocsPage(db, pageId, user.id);
+  if (!result) {
+    throw createError({ statusCode: 404, statusMessage: 'Page not found or not authorized' });
+  }
+
+  return { success: true };
+});

package/server/api/docs/[siteSlug]/pages/[pageId].get.ts

@@ -0,0 +1,31 @@
+import { getDocsSiteBySlug, listDocsPages } from '@commonpub/server';
+import { renderMarkdown } from '@commonpub/docs';
+
+export default defineEventHandler(async (event) => {
+  const db = useDB();
+  const { siteSlug, pageId: pageSlug } = parseParams(event, { siteSlug: 'string', pageId: 'string' });
+  const query = getQuery(event) as { version?: string };
+
+  const result = await getDocsSiteBySlug(db, siteSlug);
+  if (!result) throw createError({ statusCode: 404, statusMessage: 'Docs site not found' });
+
+  const version = query.version
+    ? result.versions.find((v) => v.version === query.version)
+    : result.versions.find((v) => v.isDefault) ?? result.versions[0];
+
+  if (!version) throw createError({ statusCode: 404, statusMessage: 'No version found' });
+
+  const pages = await listDocsPages(db, version.id);
+  const page = pages.find((p) => p.slug === pageSlug);
+  if (!page) throw createError({ statusCode: 404, statusMessage: 'Page not found' });
+
+  // Render markdown to HTML with TOC extraction
+  const rendered = await renderMarkdown(page.content ?? '');
+
+  return {
+    ...page,
+    html: rendered.html,
+    toc: rendered.toc,
+    frontmatter: rendered.frontmatter,
+  };
+});

package/server/api/docs/[siteSlug]/pages/[pageId].put.ts

@@ -0,0 +1,15 @@
+import { updateDocsPage } from '@commonpub/server';
+import { updateDocsPageSchema } from '@commonpub/schema';
+
+export default defineEventHandler(async (event) => {
+  const user = requireAuth(event);
+  const db = useDB();
+  const { pageId } = parseParams(event, { pageId: 'uuid' });
+  const input = await parseBody(event, updateDocsPageSchema);
+
+  const page = await updateDocsPage(db, pageId, user.id, input);
+  if (!page) {
+    throw createError({ statusCode: 404, statusMessage: 'Page not found or not owned by you' });
+  }
+  return page;
+});

package/server/api/docs/[siteSlug]/pages/index.get.ts

@@ -0,0 +1,34 @@
+import { getDocsSiteBySlug, listDocsPages } from '@commonpub/server';
+import { z } from 'zod';
+
+const pagesQuerySchema = z.object({
+  version: z.string().max(32).optional(),
+});
+
+export default defineEventHandler(async (event) => {
+  const db = useDB();
+  const { siteSlug } = parseParams(event, { siteSlug: 'string' });
+  const query = parseQueryParams(event, pagesQuerySchema);
+
+  const result = await getDocsSiteBySlug(db, siteSlug);
+  if (!result) {
+    throw createError({ statusCode: 404, statusMessage: 'Docs site not found' });
+  }
+
+  // Find the requested version or fall back to the default version
+  const requestedVersion = query.version;
+  let version = requestedVersion
+    ? result.versions.find((v) => v.version === requestedVersion)
+    : result.versions.find((v) => v.isDefault === true);
+
+  // Fall back to first version if no default found
+  if (!version && result.versions.length > 0) {
+    version = result.versions[0];
+  }
+
+  if (!version) {
+    throw createError({ statusCode: 404, statusMessage: 'No version found for docs site' });
+  }
+
+  return listDocsPages(db, version.id);
+});

package/server/api/docs/[siteSlug]/pages/index.post.ts

@@ -0,0 +1,28 @@
+import { getDocsSiteBySlug, createDocsPage } from '@commonpub/server';
+import { createDocsPageSchema } from '@commonpub/schema';
+
+export default defineEventHandler(async (event) => {
+  const user = requireAuth(event);
+  const db = useDB();
+  const { siteSlug } = parseParams(event, { siteSlug: 'string' });
+  const input = await parseBody(event, createDocsPageSchema);
+
+  const data = { ...input };
+
+  // If no versionId provided, resolve from the site's default version
+  if (!data.versionId) {
+    const result = await getDocsSiteBySlug(db, siteSlug);
+    if (!result) {
+      throw createError({ statusCode: 404, statusMessage: 'Docs site not found' });
+    }
+
+    const defaultVersion = result.versions.find((v) => v.isDefault === true) ?? result.versions[0];
+    if (!defaultVersion) {
+      throw createError({ statusCode: 404, statusMessage: 'No version found for docs site' });
+    }
+
+    data.versionId = defaultVersion.id;
+  }
+
+  return createDocsPage(db, user.id, data as typeof data & { versionId: string });
+});

package/server/api/docs/[siteSlug]/pages/reorder.post.ts

@@ -0,0 +1,26 @@
+import { reorderDocsPages, getDocsSiteBySlug } from '@commonpub/server';
+import { z } from 'zod';
+
+const reorderSchema = z.object({
+  pageIds: z.array(z.string().uuid()),
+});
+
+export default defineEventHandler(async (event) => {
+  const user = requireAuth(event);
+  const db = useDB();
+  const { siteSlug } = parseParams(event, { siteSlug: 'string' });
+  const body = await parseBody(event, reorderSchema);
+
+  const site = await getDocsSiteBySlug(db, siteSlug);
+  if (!site) throw createError({ statusCode: 404, statusMessage: 'Docs site not found' });
+
+  const version = site.versions.find((v) => v.isDefault) ?? site.versions[0];
+  if (!version) throw createError({ statusCode: 404, statusMessage: 'No version found' });
+
+  const result = await reorderDocsPages(db, version.id, user.id, body.pageIds);
+  if (!result) {
+    throw createError({ statusCode: 403, statusMessage: 'Not authorized' });
+  }
+
+  return { success: true };
+});

package/server/api/docs/[siteSlug]/search.get.ts

@@ -0,0 +1,20 @@
+import { searchDocsPages, getDocsSiteBySlug } from '@commonpub/server';
+import { z } from 'zod';
+
+const searchQuerySchema = z.object({
+  q: z.string().max(200).optional(),
+});
+
+export default defineEventHandler(async (event) => {
+  const db = useDB();
+  const { siteSlug } = parseParams(event, { siteSlug: 'string' });
+  const query = parseQueryParams(event, searchQuerySchema);
+
+  const result = await getDocsSiteBySlug(db, siteSlug);
+  if (!result) throw createError({ statusCode: 404, statusMessage: 'Docs site not found' });
+
+  const version = result.versions?.find((v) => v.isDefault) ?? result.versions?.[0];
+  if (!version) return [];
+
+  return searchDocsPages(db, result.site.id, version.id, query.q ?? '');
+});

package/server/api/docs/[siteSlug]/versions.post.ts

@@ -0,0 +1,11 @@
+import { createDocsVersion } from '@commonpub/server';
+import { createDocsVersionSchema } from '@commonpub/schema';
+
+export default defineEventHandler(async (event) => {
+  const user = requireAuth(event);
+  const db = useDB();
+  const { siteSlug } = parseParams(event, { siteSlug: 'string' });
+  const input = await parseBody(event, createDocsVersionSchema);
+
+  return createDocsVersion(db, siteSlug, user.id, input);
+});

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

@@ -0,0 +1,6 @@
+import { listDocsSites } from '@commonpub/server';
+
+export default defineEventHandler(async (_event) => {
+  const db = useDB();
+  return listDocsSites(db);
+});

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

@@ -0,0 +1,10 @@
+import { createDocsSite } from '@commonpub/server';
+import { createDocsSiteSchema } from '@commonpub/schema';
+
+export default defineEventHandler(async (event) => {
+  const user = requireAuth(event);
+  const db = useDB();
+  const input = await parseBody(event, createDocsSiteSchema);
+
+  return createDocsSite(db, user.id, input);
+});

package/server/api/federated-hubs/[id]/posts/[postId].get.ts

@@ -0,0 +1,16 @@
+import { getFederatedHubPost } from '@commonpub/server';
+
+export default defineEventHandler(async (event) => {
+  requireFeature('federation');
+  requireFeature('federateHubs');
+
+  const db = useDB();
+  const { postId } = parseParams(event, { postId: 'uuid' });
+
+  const post = await getFederatedHubPost(db, postId);
+  if (!post) {
+    throw createError({ statusCode: 404, statusMessage: 'Federated hub post not found' });
+  }
+
+  return post;
+});

package/server/api/federated-hubs/[id]/posts.get.ts

@@ -0,0 +1,15 @@
+import { listFederatedHubPosts } from '@commonpub/server';
+
+export default defineEventHandler(async (event) => {
+  requireFeature('federation');
+  requireFeature('federateHubs');
+
+  const db = useDB();
+  const { id } = parseParams(event, { id: 'uuid' });
+  const query = getQuery(event);
+
+  return listFederatedHubPosts(db, id, {
+    limit: query.limit ? Number(query.limit) : undefined,
+    offset: query.offset ? Number(query.offset) : undefined,
+  });
+});

package/server/api/federated-hubs/[id].get.ts

@@ -0,0 +1,16 @@
+import { getFederatedHub } from '@commonpub/server';
+
+export default defineEventHandler(async (event) => {
+  requireFeature('federation');
+  requireFeature('federateHubs');
+
+  const db = useDB();
+  const { id } = parseParams(event, { id: 'uuid' });
+
+  const hub = await getFederatedHub(db, id);
+  if (!hub) {
+    throw createError({ statusCode: 404, statusMessage: 'Federated hub not found' });
+  }
+
+  return hub;
+});

package/server/api/federation/boost.post.ts

@@ -0,0 +1,21 @@
+import { boostRemoteContent } from '@commonpub/server';
+import { z } from 'zod';
+
+const boostSchema = z.object({
+  federatedContentId: z.string().uuid(),
+});
+
+export default defineEventHandler(async (event): Promise<{ success: boolean }> => {
+  requireFeature('federation');
+  const user = requireAuth(event);
+  const db = useDB();
+  const config = useConfig();
+  const { federatedContentId } = await parseBody(event, boostSchema);
+
+  const success = await boostRemoteContent(db, user.id, federatedContentId, config.instance.domain);
+  if (!success) {
+    throw createError({ statusCode: 404, statusMessage: 'Content not found' });
+  }
+
+  return { success };
+});

package/server/api/federation/content/[id].get.ts

@@ -0,0 +1,15 @@
+import { getFederatedContent } from '@commonpub/server';
+import type { FederatedContentItem } from '@commonpub/server';
+
+export default defineEventHandler(async (event): Promise<FederatedContentItem> => {
+  requireFeature('federation');
+  const db = useDB();
+  const { id } = parseParams(event, { id: 'uuid' });
+
+  const content = await getFederatedContent(db, id);
+  if (!content) {
+    throw createError({ statusCode: 404, statusMessage: 'Federated content not found' });
+  }
+
+  return content;
+});

package/server/api/federation/follow.post.ts

@@ -0,0 +1,16 @@
+import { sendFollow } from '@commonpub/server';
+import { z } from 'zod';
+
+const followSchema = z.object({
+  actorUri: z.string().url(),
+});
+
+export default defineEventHandler(async (event): Promise<{ id: string }> => {
+  requireFeature('federation');
+  const user = requireAuth(event);
+  const db = useDB();
+  const config = useConfig();
+  const { actorUri } = await parseBody(event, followSchema);
+
+  return sendFollow(db, user.id, actorUri, config.instance.domain);
+});

package/server/api/federation/health.get.ts

@@ -0,0 +1,56 @@
+import { activities, followRelationships, instanceMirrors, federatedContent } from '@commonpub/schema';
+import { sql } from 'drizzle-orm';
+
+/**
+ * GET /api/federation/health
+ * Public health check for federation status. No auth required.
+ */
+export default defineEventHandler(async (event) => {
+  const config = useConfig();
+  if (!config.features.federation) {
+    return { enabled: false };
+  }
+
+  const db = useDB();
+
+  const [activityStats] = await db
+    .select({
+      pending: sql<number>`count(*) filter (where ${activities.direction} = 'outbound' and ${activities.status} = 'pending')`,
+      delivered: sql<number>`count(*) filter (where ${activities.direction} = 'outbound' and ${activities.status} = 'delivered')`,
+      failed: sql<number>`count(*) filter (where ${activities.direction} = 'outbound' and ${activities.status} = 'failed')`,
+      inbound: sql<number>`count(*) filter (where ${activities.direction} = 'inbound')`,
+    })
+    .from(activities);
+
+  const [followStats] = await db
+    .select({
+      followers: sql<number>`count(*) filter (where ${followRelationships.status} = 'accepted')`,
+    })
+    .from(followRelationships);
+
+  const [mirrorStats] = await db
+    .select({
+      active: sql<number>`count(*) filter (where ${instanceMirrors.status} = 'active')`,
+    })
+    .from(instanceMirrors);
+
+  const [contentStats] = await db
+    .select({
+      total: sql<number>`count(*)`,
+    })
+    .from(federatedContent);
+
+  return {
+    enabled: true,
+    domain: config.instance.domain,
+    activities: {
+      pending: Number(activityStats?.pending ?? 0),
+      delivered: Number(activityStats?.delivered ?? 0),
+      failed: Number(activityStats?.failed ?? 0),
+      inbound: Number(activityStats?.inbound ?? 0),
+    },
+    followers: Number(followStats?.followers ?? 0),
+    mirrors: Number(mirrorStats?.active ?? 0),
+    federatedContent: Number(contentStats?.total ?? 0),
+  };
+});