emdash 0.0.0-a → 0.0.1

package/src/astro/routes/api/admin/allowed-domains/index.ts

@@ -0,0 +1,108 @@
+/**
+ * GET/POST /_emdash/api/admin/allowed-domains
+ *
+ * Admin endpoints for managing allowed signup domains.
+ * GET - List all allowed domains
+ * POST - Add a new allowed domain
+ */
+
+import type { APIRoute } from "astro";
+
+export const prerender = false;
+
+import { Role, roleFromLevel } from "@emdash-cms/auth";
+import { createKyselyAdapter } from "@emdash-cms/auth/adapters/kysely";
+
+import { apiError, apiSuccess, handleError } from "#api/error.js";
+import { isParseError, parseBody } from "#api/parse.js";
+import { allowedDomainCreateBody } from "#api/schemas.js";
+
+const DOMAIN_REGEX = /^[a-zA-Z0-9][a-zA-Z0-9-]*(\.[a-zA-Z0-9-]+)+$/;
+
+/**
+ * GET - List all allowed domains
+ */
+export const GET: APIRoute = async ({ locals }) => {
+	const { emdash, user } = locals;
+
+	if (!emdash?.db) {
+		return apiError("NOT_CONFIGURED", "Database not configured", 500);
+	}
+
+	if (!user || user.role < Role.ADMIN) {
+		return apiError("FORBIDDEN", "Admin privileges required", 403);
+	}
+
+	const adapter = createKyselyAdapter(emdash.db);
+
+	try {
+		const domains = await adapter.getAllowedDomains();
+
+		return apiSuccess({
+			domains: domains.map((d) => ({
+				domain: d.domain,
+				defaultRole: d.defaultRole,
+				roleName: roleFromLevel(d.defaultRole),
+				enabled: d.enabled,
+				createdAt: d.createdAt.toISOString(),
+			})),
+		});
+	} catch (error) {
+		return handleError(error, "Failed to list allowed domains", "DOMAIN_LIST_ERROR");
+	}
+};
+
+/**
+ * POST - Add a new allowed domain
+ */
+export const POST: APIRoute = async ({ request, locals }) => {
+	const { emdash, user } = locals;
+
+	if (!emdash?.db) {
+		return apiError("NOT_CONFIGURED", "Database not configured", 500);
+	}
+
+	if (!user || user.role < Role.ADMIN) {
+		return apiError("FORBIDDEN", "Admin privileges required", 403);
+	}
+
+	const adapter = createKyselyAdapter(emdash.db);
+
+	try {
+		const body = await parseBody(request, allowedDomainCreateBody);
+		if (isParseError(body)) return body;
+
+		// Role is already validated as RoleLevel by Zod schema
+		const defaultRole = body.defaultRole;
+
+		// Validate domain format (no protocol, just domain)
+		const cleanDomain = body.domain.toLowerCase().trim();
+		if (!DOMAIN_REGEX.test(cleanDomain)) {
+			return apiError("VALIDATION_ERROR", "Invalid domain format", 400);
+		}
+
+		// Check if domain already exists
+		const existing = await adapter.getAllowedDomain(cleanDomain);
+		if (existing) {
+			return apiError("CONFLICT", "Domain already exists", 409);
+		}
+
+		const domain = await adapter.createAllowedDomain(cleanDomain, defaultRole);
+
+		return apiSuccess(
+			{
+				success: true,
+				domain: {
+					domain: domain.domain,
+					defaultRole: domain.defaultRole,
+					roleName: roleFromLevel(domain.defaultRole),
+					enabled: domain.enabled,
+					createdAt: domain.createdAt.toISOString(),
+				},
+			},
+			201,
+		);
+	} catch (error) {
+		return handleError(error, "Failed to create allowed domain", "DOMAIN_CREATE_ERROR");
+	}
+};

package/src/astro/routes/api/admin/api-tokens/[id].ts

@@ -0,0 +1,40 @@
+/**
+ * Single API token endpoint
+ *
+ * DELETE /_emdash/api/admin/api-tokens/:id — Revoke a token
+ */
+
+import { Role } from "@emdash-cms/auth";
+import type { APIRoute } from "astro";
+
+import { apiError, handleError, unwrapResult } from "#api/error.js";
+import { handleApiTokenRevoke } from "#api/handlers/api-tokens.js";
+
+export const prerender = false;
+
+/**
+ * Revoke (delete) an API token.
+ */
+export const DELETE: APIRoute = async ({ params, locals }) => {
+	const { emdash, user } = locals;
+
+	if (!emdash?.db) {
+		return apiError("NOT_CONFIGURED", "EmDash is not initialized", 500);
+	}
+
+	if (!user || user.role < Role.ADMIN) {
+		return apiError("FORBIDDEN", "Admin privileges required", 403);
+	}
+
+	const tokenId = params.id;
+	if (!tokenId) {
+		return apiError("VALIDATION_ERROR", "Token ID is required", 400);
+	}
+
+	try {
+		const result = await handleApiTokenRevoke(emdash.db, tokenId, user.id);
+		return unwrapResult(result);
+	} catch (error) {
+		return handleError(error, "Failed to revoke API token", "TOKEN_REVOKE_ERROR");
+	}
+};

package/src/astro/routes/api/admin/api-tokens/index.ts

@@ -0,0 +1,68 @@
+/**
+ * API token management endpoints
+ *
+ * GET  /_emdash/api/admin/api-tokens — List tokens for current user
+ * POST /_emdash/api/admin/api-tokens — Create a new token
+ */
+
+import { Role } from "@emdash-cms/auth";
+import type { APIRoute } from "astro";
+import { z } from "zod";
+
+import { apiError, handleError, unwrapResult } from "#api/error.js";
+import { handleApiTokenCreate, handleApiTokenList } from "#api/handlers/api-tokens.js";
+import { isParseError, parseBody } from "#api/parse.js";
+import { VALID_SCOPES } from "#auth/api-tokens.js";
+
+export const prerender = false;
+
+const createTokenSchema = z.object({
+	name: z.string().min(1).max(100),
+	scopes: z.array(z.enum(VALID_SCOPES)).min(1),
+	expiresAt: z.string().datetime().optional(),
+});
+
+/**
+ * List API tokens for the current user.
+ * Admins can list all tokens (future: add ?userId= filter).
+ */
+export const GET: APIRoute = async ({ locals }) => {
+	const { emdash, user } = locals;
+
+	if (!emdash?.db) {
+		return apiError("NOT_CONFIGURED", "EmDash is not initialized", 500);
+	}
+
+	if (!user || user.role < Role.ADMIN) {
+		return apiError("FORBIDDEN", "Admin privileges required", 403);
+	}
+
+	const result = await handleApiTokenList(emdash.db, user.id);
+	return unwrapResult(result);
+};
+
+/**
+ * Create a new API token.
+ * Returns the raw token once — it cannot be retrieved again.
+ */
+export const POST: APIRoute = async ({ request, locals }) => {
+	const { emdash, user } = locals;
+
+	if (!emdash?.db) {
+		return apiError("NOT_CONFIGURED", "EmDash is not initialized", 500);
+	}
+
+	if (!user || user.role < Role.ADMIN) {
+		return apiError("FORBIDDEN", "Admin privileges required", 403);
+	}
+
+	try {
+		const body = await parseBody(request, createTokenSchema);
+		if (isParseError(body)) return body;
+
+		const result = await handleApiTokenCreate(emdash.db, user.id, body);
+		return unwrapResult(result, 201);
+	} catch (error) {
+		return handleError(error, "Failed to create API token", "TOKEN_CREATE_ERROR");
+	}
+};

package/src/astro/routes/api/admin/bylines/[id]/index.ts

@@ -0,0 +1,87 @@
+import { Role } from "@emdash-cms/auth";
+import type { APIRoute } from "astro";
+
+import { requirePerm } from "#api/authorize.js";
+import { apiError, apiSuccess, handleError } from "#api/error.js";
+import { isParseError, parseBody } from "#api/parse.js";
+import { bylineUpdateBody } from "#api/schemas.js";
+import { BylineRepository } from "#db/repositories/byline.js";
+
+export const prerender = false;
+
+function requireEditor(user: { role: number } | undefined): Response | null {
+	if (!user || user.role < Role.EDITOR) {
+		return apiError("FORBIDDEN", "Editor privileges required", 403);
+	}
+	return null;
+}
+
+export const GET: APIRoute = async ({ params, locals }) => {
+	const { emdash, user } = locals;
+	// Read access uses content:read so all authenticated roles can view byline data
+	const denied = requirePerm(user, "content:read");
+	if (denied) return denied;
+
+	if (!emdash?.db) {
+		return apiError("NOT_CONFIGURED", "EmDash is not initialized", 500);
+	}
+
+	try {
+		const repo = new BylineRepository(emdash.db);
+		const byline = await repo.findById(params.id!);
+		if (!byline) return apiError("NOT_FOUND", "Byline not found", 404);
+		return apiSuccess(byline);
+	} catch (error) {
+		return handleError(error, "Failed to get byline", "BYLINE_GET_ERROR");
+	}
+};
+
+export const PUT: APIRoute = async ({ params, request, locals }) => {
+	const { emdash, user } = locals;
+	const denied = requireEditor(user);
+	if (denied) return denied;
+
+	if (!emdash?.db) {
+		return apiError("NOT_CONFIGURED", "EmDash is not initialized", 500);
+	}
+
+	const body = await parseBody(request, bylineUpdateBody);
+	if (isParseError(body)) return body;
+
+	try {
+		const repo = new BylineRepository(emdash.db);
+		const byline = await repo.update(params.id!, {
+			slug: body.slug,
+			displayName: body.displayName,
+			bio: body.bio ?? null,
+			avatarMediaId: body.avatarMediaId ?? null,
+			websiteUrl: body.websiteUrl ?? null,
+			userId: body.userId ?? null,
+			isGuest: body.isGuest,
+		});
+
+		if (!byline) return apiError("NOT_FOUND", "Byline not found", 404);
+		return apiSuccess(byline);
+	} catch (error) {
+		return handleError(error, "Failed to update byline", "BYLINE_UPDATE_ERROR");
+	}
+};
+
+export const DELETE: APIRoute = async ({ params, locals }) => {
+	const { emdash, user } = locals;
+	const denied = requireEditor(user);
+	if (denied) return denied;
+
+	if (!emdash?.db) {
+		return apiError("NOT_CONFIGURED", "EmDash is not initialized", 500);
+	}
+
+	try {
+		const repo = new BylineRepository(emdash.db);
+		const deleted = await repo.delete(params.id!);
+		if (!deleted) return apiError("NOT_FOUND", "Byline not found", 404);
+		return apiSuccess({ deleted: true });
+	} catch (error) {
+		return handleError(error, "Failed to delete byline", "BYLINE_DELETE_ERROR");
+	}
+};

package/src/astro/routes/api/admin/bylines/index.ts

@@ -0,0 +1,72 @@
+import { Role } from "@emdash-cms/auth";
+import type { APIRoute } from "astro";
+
+import { requirePerm } from "#api/authorize.js";
+import { apiError, apiSuccess, handleError } from "#api/error.js";
+import { isParseError, parseBody, parseQuery } from "#api/parse.js";
+import { bylineCreateBody, bylinesListQuery } from "#api/schemas.js";
+import { BylineRepository } from "#db/repositories/byline.js";
+
+export const prerender = false;
+
+export const GET: APIRoute = async ({ url, locals }) => {
+	const { emdash, user } = locals;
+
+	if (!emdash?.db) {
+		return apiError("NOT_CONFIGURED", "EmDash is not initialized", 500);
+	}
+
+	// Read access uses content:read so all authenticated roles can view byline data
+	const denied = requirePerm(user, "content:read");
+	if (denied) return denied;
+
+	const query = parseQuery(url, bylinesListQuery);
+	if (isParseError(query)) return query;
+
+	try {
+		const repo = new BylineRepository(emdash.db);
+		const result = await repo.findMany({
+			search: query.search,
+			isGuest: query.isGuest,
+			userId: query.userId,
+			cursor: query.cursor,
+			limit: query.limit,
+		});
+
+		return apiSuccess(result);
+	} catch (error) {
+		return handleError(error, "Failed to list bylines", "BYLINE_LIST_ERROR");
+	}
+};
+
+export const POST: APIRoute = async ({ request, locals }) => {
+	const { emdash, user } = locals;
+
+	if (!emdash?.db) {
+		return apiError("NOT_CONFIGURED", "EmDash is not initialized", 500);
+	}
+
+	if (!user || user.role < Role.EDITOR) {
+		return apiError("FORBIDDEN", "Editor privileges required", 403);
+	}
+
+	const body = await parseBody(request, bylineCreateBody);
+	if (isParseError(body)) return body;
+
+	try {
+		const repo = new BylineRepository(emdash.db);
+		const byline = await repo.create({
+			slug: body.slug,
+			displayName: body.displayName,
+			bio: body.bio ?? null,
+			avatarMediaId: body.avatarMediaId ?? null,
+			websiteUrl: body.websiteUrl ?? null,
+			userId: body.userId ?? null,
+			isGuest: body.isGuest,
+		});
+
+		return apiSuccess(byline, 201);
+	} catch (error) {
+		return handleError(error, "Failed to create byline", "BYLINE_CREATE_ERROR");
+	}
+};

package/src/astro/routes/api/admin/comments/[id]/status.ts

@@ -0,0 +1,120 @@
+/**
+ * Comment status change
+ *
+ * PUT /_emdash/api/admin/comments/:id/status - Change comment status
+ */
+
+import type { APIRoute } from "astro";
+
+import { requirePerm } from "#api/authorize.js";
+import { apiError, apiSuccess, handleError, requireDb, unwrapResult } from "#api/error.js";
+import { handleCommentGet } from "#api/handlers/comments.js";
+import { isParseError, parseBody } from "#api/parse.js";
+import { commentStatusBody } from "#api/schemas.js";
+import { getSiteBaseUrl } from "#api/site-url.js";
+import { lookupContentAuthor, sendCommentNotification } from "#comments/notifications.js";
+import { moderateComment, type CommentHookRunner } from "#comments/service.js";
+import type { CommentStatus } from "#db/repositories/comment.js";
+import type { ModerationDecision } from "#plugins/types.js";
+
+export const prerender = false;
+
+export const PUT: APIRoute = async ({ params, request, locals }) => {
+	const { emdash, user } = locals;
+	const { id } = params;
+
+	if (!id) {
+		return apiError("VALIDATION_ERROR", "Comment ID required", 400);
+	}
+
+	const dbErr = requireDb(emdash?.db);
+	if (dbErr) return dbErr;
+
+	const denied = requirePerm(user, "comments:moderate");
+	if (denied) return denied;
+
+	try {
+		const body = await parseBody(request, commentStatusBody);
+		if (isParseError(body)) return body;
+
+		const newStatus = body.status as CommentStatus;
+
+		// Build hook runner for the service
+		const hookRunner: CommentHookRunner = {
+			async runBeforeCreate(event) {
+				return emdash.hooks.runCommentBeforeCreate(event);
+			},
+			async runModerate(event) {
+				const result = await emdash.hooks.invokeExclusiveHook("comment:moderate", event);
+				if (!result) return { status: "pending" as const, reason: "No moderator configured" };
+				if (result.error) return { status: "pending" as const, reason: "Moderation error" };
+				return result.result as ModerationDecision;
+			},
+			fireAfterCreate(event) {
+				emdash.hooks
+					.runCommentAfterCreate(event)
+					.catch((err) =>
+						console.error(
+							"[comments] afterCreate error:",
+							err instanceof Error ? err.message : err,
+						),
+					);
+			},
+			fireAfterModerate(event) {
+				emdash.hooks
+					.runCommentAfterModerate(event)
+					.catch((err) =>
+						console.error(
+							"[comments] afterModerate error:",
+							err instanceof Error ? err.message : err,
+						),
+					);
+			},
+		};
+
+		// Read the comment before updating so we know the previous status
+		const existing = await handleCommentGet(emdash.db, id);
+		if (!existing.success) {
+			return unwrapResult(existing);
+		}
+		const previousStatus = existing.data.status;
+
+		const updated = await moderateComment(
+			emdash.db,
+			id,
+			newStatus,
+			{ id: user!.id, name: user!.name ?? null },
+			hookRunner,
+		);
+
+		if (!updated) {
+			return apiError("NOT_FOUND", "Comment not found", 404);
+		}
+
+		// Send notification when a comment is newly approved
+		if (newStatus === "approved" && previousStatus !== "approved" && emdash.email) {
+			try {
+				const adminBaseUrl = await getSiteBaseUrl(emdash.db, request);
+				const content = await lookupContentAuthor(
+					emdash.db,
+					updated.collection,
+					updated.contentId,
+				);
+				if (content?.author) {
+					await sendCommentNotification({
+						email: emdash.email,
+						comment: updated,
+						contentAuthor: content.author,
+						adminBaseUrl,
+					});
+				}
+			} catch (err) {
+				console.error("[comments] notification error:", err instanceof Error ? err.message : err);
+			}
+		}
+
+		return apiSuccess(updated);
+	} catch (error) {
+		return handleError(error, "Failed to update comment status", "COMMENT_STATUS_ERROR");
+	}
+};

package/src/astro/routes/api/admin/comments/[id].ts

@@ -0,0 +1,64 @@
+/**
+ * Single comment admin endpoints
+ *
+ * GET    /_emdash/api/admin/comments/:id - Get comment detail
+ * DELETE /_emdash/api/admin/comments/:id - Hard delete (ADMIN only)
+ */
+
+import type { APIRoute } from "astro";
+
+import { requirePerm } from "#api/authorize.js";
+import { apiError, handleError, requireDb, unwrapResult } from "#api/error.js";
+import { handleCommentGet, handleCommentDelete } from "#api/handlers/comments.js";
+
+export const prerender = false;
+
+/**
+ * Get single comment detail (includes moderation_metadata)
+ */
+export const GET: APIRoute = async ({ params, locals }) => {
+	const { emdash, user } = locals;
+	const { id } = params;
+
+	if (!id) {
+		return apiError("VALIDATION_ERROR", "Comment ID required", 400);
+	}
+
+	const dbErr = requireDb(emdash?.db);
+	if (dbErr) return dbErr;
+
+	const denied = requirePerm(user, "comments:moderate");
+	if (denied) return denied;
+
+	try {
+		const result = await handleCommentGet(emdash.db, id);
+		return unwrapResult(result);
+	} catch (error) {
+		return handleError(error, "Failed to get comment", "COMMENT_GET_ERROR");
+	}
+};
+
+/**
+ * Hard delete a comment (ADMIN only)
+ */
+export const DELETE: APIRoute = async ({ params, locals }) => {
+	const { emdash, user } = locals;
+	const { id } = params;
+
+	if (!id) {
+		return apiError("VALIDATION_ERROR", "Comment ID required", 400);
+	}
+
+	const dbErr = requireDb(emdash?.db);
+	if (dbErr) return dbErr;
+
+	const denied = requirePerm(user, "comments:delete");
+	if (denied) return denied;
+
+	try {
+		const result = await handleCommentDelete(emdash.db, id);
+		return unwrapResult(result);
+	} catch (error) {
+		return handleError(error, "Failed to delete comment", "COMMENT_DELETE_ERROR");
+	}
+};

package/src/astro/routes/api/admin/comments/bulk.ts

@@ -0,0 +1,42 @@
+/**
+ * Bulk comment operations
+ *
+ * POST /_emdash/api/admin/comments/bulk - Bulk status change or delete
+ */
+
+import type { APIRoute } from "astro";
+
+import { requirePerm } from "#api/authorize.js";
+import { handleError, requireDb, unwrapResult } from "#api/error.js";
+import { handleCommentBulk } from "#api/handlers/comments.js";
+import { isParseError, parseBody } from "#api/parse.js";
+import { commentBulkBody } from "#api/schemas.js";
+
+export const prerender = false;
+
+export const POST: APIRoute = async ({ request, locals }) => {
+	const { emdash, user } = locals;
+
+	const dbErr = requireDb(emdash?.db);
+	if (dbErr) return dbErr;
+
+	try {
+		const body = await parseBody(request, commentBulkBody);
+		if (isParseError(body)) return body;
+
+		// Bulk delete requires ADMIN, bulk status change requires EDITOR
+		if (body.action === "delete") {
+			const denied = requirePerm(user, "comments:delete");
+			if (denied) return denied;
+		} else {
+			const denied = requirePerm(user, "comments:moderate");
+			if (denied) return denied;
+		}
+
+		const result = await handleCommentBulk(emdash.db, body.ids, body.action);
+
+		return unwrapResult(result);
+	} catch (error) {
+		return handleError(error, "Failed to perform bulk operation", "COMMENT_BULK_ERROR");
+	}
+};

package/src/astro/routes/api/admin/comments/counts.ts

@@ -0,0 +1,30 @@
+/**
+ * Comment status counts for inbox badges
+ *
+ * GET /_emdash/api/admin/comments/counts
+ */
+
+import type { APIRoute } from "astro";
+
+import { requirePerm } from "#api/authorize.js";
+import { handleError, requireDb, unwrapResult } from "#api/error.js";
+import { handleCommentCounts } from "#api/handlers/comments.js";
+
+export const prerender = false;
+
+export const GET: APIRoute = async ({ locals }) => {
+	const { emdash, user } = locals;
+
+	const dbErr = requireDb(emdash?.db);
+	if (dbErr) return dbErr;
+
+	const denied = requirePerm(user, "comments:moderate");
+	if (denied) return denied;
+
+	try {
+		const result = await handleCommentCounts(emdash.db);
+		return unwrapResult(result);
+	} catch (error) {
+		return handleError(error, "Failed to get comment counts", "COMMENT_COUNTS_ERROR");
+	}
+};

package/src/astro/routes/api/admin/comments/index.ts

@@ -0,0 +1,46 @@
+/**
+ * Admin comment inbox
+ *
+ * GET /_emdash/api/admin/comments - List comments (filterable by status, collection, search)
+ */
+
+import type { APIRoute } from "astro";
+
+import { requirePerm } from "#api/authorize.js";
+import { handleError, requireDb, unwrapResult } from "#api/error.js";
+import { handleCommentInbox } from "#api/handlers/comments.js";
+import { isParseError, parseQuery } from "#api/parse.js";
+import { commentListQuery } from "#api/schemas.js";
+import type { CommentStatus } from "#db/repositories/comment.js";
+
+export const prerender = false;
+
+/**
+ * List comments for moderation inbox
+ */
+export const GET: APIRoute = async ({ url, locals }) => {
+	const { emdash, user } = locals;
+
+	const dbErr = requireDb(emdash?.db);
+	if (dbErr) return dbErr;
+
+	const denied = requirePerm(user, "comments:moderate");
+	if (denied) return denied;
+
+	try {
+		const query = parseQuery(url, commentListQuery);
+		if (isParseError(query)) return query;
+
+		const result = await handleCommentInbox(emdash.db, {
+			status: query.status as CommentStatus | undefined,
+			collection: query.collection,
+			search: query.search,
+			limit: query.limit,
+			cursor: query.cursor,
+		});
+
+		return unwrapResult(result);
+	} catch (error) {
+		return handleError(error, "Failed to list comments", "COMMENT_INBOX_ERROR");
+	}
+};