emdash 0.0.0-b → 0.0.2

package/src/api/handlers/sections.ts

@@ -0,0 +1,289 @@
+/**
+ * Section CRUD handlers
+ */
+
+import type { Kysely } from "kysely";
+import { ulid } from "ulidx";
+
+import type { FindManyResult } from "../../database/repositories/types.js";
+import type { Database } from "../../database/types.js";
+import {
+	getSectionById,
+	getSectionWithDb,
+	getSectionsWithDb,
+	type Section,
+	type GetSectionsOptions,
+} from "../../sections/index.js";
+import type { ApiResult } from "../types.js";
+
+const SLUG_PATTERN = /^[a-z0-9-]+$/;
+
+export type SectionListResponse = FindManyResult<Section>;
+
+/**
+ * List sections with optional filters
+ */
+export async function handleSectionList(
+	db: Kysely<Database>,
+	params: GetSectionsOptions,
+): Promise<ApiResult<SectionListResponse>> {
+	try {
+		const result = await getSectionsWithDb(db, {
+			source: params.source,
+			search: params.search,
+			limit: params.limit,
+			cursor: params.cursor,
+		});
+
+		return { success: true, data: result };
+	} catch {
+		return {
+			success: false,
+			error: { code: "SECTION_LIST_ERROR", message: "Failed to fetch sections" },
+		};
+	}
+}
+
+/**
+ * Create a section
+ */
+export async function handleSectionCreate(
+	db: Kysely<Database>,
+	input: {
+		slug: string;
+		title: string;
+		description?: string;
+		keywords?: string[];
+		content: unknown[];
+		previewMediaId?: string;
+		source?: string;
+		themeId?: string;
+	},
+): Promise<ApiResult<Section>> {
+	try {
+		// Validate slug format
+		if (!SLUG_PATTERN.test(input.slug)) {
+			return {
+				success: false,
+				error: {
+					code: "VALIDATION_ERROR",
+					message: "slug must only contain lowercase letters, numbers, and hyphens",
+				},
+			};
+		}
+
+		// Check if slug already exists
+		const existing = await db
+			.selectFrom("_emdash_sections")
+			.select("id")
+			.where("slug", "=", input.slug)
+			.executeTakeFirst();
+
+		if (existing) {
+			return {
+				success: false,
+				error: {
+					code: "CONFLICT",
+					message: `Section with slug "${input.slug}" already exists`,
+				},
+			};
+		}
+
+		const id = ulid();
+		const now = new Date().toISOString();
+
+		await db
+			.insertInto("_emdash_sections")
+			.values({
+				id,
+				slug: input.slug,
+				title: input.title,
+				description: input.description ?? null,
+				keywords: input.keywords ? JSON.stringify(input.keywords) : null,
+				content: JSON.stringify(input.content),
+				preview_media_id: input.previewMediaId ?? null,
+				source: input.source ?? "user",
+				theme_id: input.themeId ?? null,
+				created_at: now,
+				updated_at: now,
+			})
+			.execute();
+
+		const section = await getSectionById(id, db);
+		if (!section) {
+			return {
+				success: false,
+				error: { code: "SECTION_CREATE_ERROR", message: "Failed to fetch created section" },
+			};
+		}
+
+		return { success: true, data: section };
+	} catch {
+		return {
+			success: false,
+			error: { code: "SECTION_CREATE_ERROR", message: "Failed to create section" },
+		};
+	}
+}
+
+/**
+ * Get a section by slug
+ */
+export async function handleSectionGet(
+	db: Kysely<Database>,
+	slug: string,
+): Promise<ApiResult<Section>> {
+	try {
+		const section = await getSectionWithDb(slug, db);
+
+		if (!section) {
+			return {
+				success: false,
+				error: { code: "NOT_FOUND", message: `Section "${slug}" not found` },
+			};
+		}
+
+		return { success: true, data: section };
+	} catch {
+		return {
+			success: false,
+			error: { code: "SECTION_GET_ERROR", message: "Failed to fetch section" },
+		};
+	}
+}
+
+/**
+ * Update a section by slug
+ */
+export async function handleSectionUpdate(
+	db: Kysely<Database>,
+	slug: string,
+	input: {
+		slug?: string;
+		title?: string;
+		description?: string;
+		keywords?: string[];
+		content?: unknown[];
+		previewMediaId?: string | null;
+	},
+): Promise<ApiResult<Section>> {
+	try {
+		// Check if section exists
+		const existing = await db
+			.selectFrom("_emdash_sections")
+			.select(["id", "source"])
+			.where("slug", "=", slug)
+			.executeTakeFirst();
+
+		if (!existing) {
+			return {
+				success: false,
+				error: { code: "NOT_FOUND", message: `Section "${slug}" not found` },
+			};
+		}
+
+		// Validate new slug if changing
+		if (input.slug && input.slug !== slug) {
+			if (!SLUG_PATTERN.test(input.slug)) {
+				return {
+					success: false,
+					error: {
+						code: "VALIDATION_ERROR",
+						message: "slug must only contain lowercase letters, numbers, and hyphens",
+					},
+				};
+			}
+
+			// Check if new slug already exists
+			const slugExists = await db
+				.selectFrom("_emdash_sections")
+				.select("id")
+				.where("slug", "=", input.slug)
+				.executeTakeFirst();
+
+			if (slugExists) {
+				return {
+					success: false,
+					error: {
+						code: "CONFLICT",
+						message: `Section with slug "${input.slug}" already exists`,
+					},
+				};
+			}
+		}
+
+		// Build update object
+		const updates: Record<string, unknown> = {
+			updated_at: new Date().toISOString(),
+		};
+
+		if (input.slug !== undefined) updates.slug = input.slug;
+		if (input.title !== undefined) updates.title = input.title;
+		if (input.description !== undefined) updates.description = input.description;
+		if (input.keywords !== undefined) updates.keywords = JSON.stringify(input.keywords);
+		if (input.content !== undefined) updates.content = JSON.stringify(input.content);
+		if (input.previewMediaId !== undefined) updates.preview_media_id = input.previewMediaId;
+
+		await db.updateTable("_emdash_sections").set(updates).where("id", "=", existing.id).execute();
+
+		const section = await getSectionById(existing.id, db);
+		if (!section) {
+			return {
+				success: false,
+				error: { code: "SECTION_UPDATE_ERROR", message: "Failed to fetch updated section" },
+			};
+		}
+
+		return { success: true, data: section };
+	} catch {
+		return {
+			success: false,
+			error: { code: "SECTION_UPDATE_ERROR", message: "Failed to update section" },
+		};
+	}
+}
+
+/**
+ * Delete a section by slug
+ */
+export async function handleSectionDelete(
+	db: Kysely<Database>,
+	slug: string,
+): Promise<ApiResult<{ deleted: true }>> {
+	try {
+		// Check if section exists and get source
+		const existing = await db
+			.selectFrom("_emdash_sections")
+			.select(["id", "source", "theme_id"])
+			.where("slug", "=", slug)
+			.executeTakeFirst();
+
+		if (!existing) {
+			return {
+				success: false,
+				error: { code: "NOT_FOUND", message: `Section "${slug}" not found` },
+			};
+		}
+
+		// Prevent deleting theme sections
+		if (existing.source === "theme") {
+			return {
+				success: false,
+				error: {
+					code: "FORBIDDEN",
+					message:
+						"Cannot delete theme-provided sections. Edit the section to create a user copy, then delete that.",
+				},
+			};
+		}
+
+		await db.deleteFrom("_emdash_sections").where("id", "=", existing.id).execute();
+
+		return { success: true, data: { deleted: true } };
+	} catch {
+		return {
+			success: false,
+			error: { code: "SECTION_DELETE_ERROR", message: "Failed to delete section" },
+		};
+	}
+}

package/src/api/handlers/seo.ts

@@ -0,0 +1,115 @@
+/**
+ * SEO Handlers
+ *
+ * Business logic for sitemap generation and robots.txt.
+ */
+
+import { sql, type Kysely } from "kysely";
+
+import type { Database } from "../../database/types.js";
+import { validateIdentifier } from "../../database/validate.js";
+import type { ApiResult } from "../types.js";
+
+/** Raw content data for sitemap generation — the route builds the actual URLs */
+export interface SitemapContentEntry {
+	/** Collection slug (e.g., "post", "page") */
+	collection: string;
+	/** Content slug or ID */
+	identifier: string;
+	/** ISO date of last modification */
+	updatedAt: string;
+}
+
+export interface SitemapDataResponse {
+	entries: SitemapContentEntry[];
+}
+
+/** Maximum entries per sitemap (per spec) */
+const SITEMAP_MAX_ENTRIES = 50_000;
+
+/**
+ * Collect all published, indexable content across SEO-enabled collections
+ * for sitemap generation.
+ *
+ * Only includes content from collections with `has_seo = 1`.
+ * Excludes content with `seo_no_index = 1` in the `_emdash_seo` table.
+ *
+ * Returns raw data (collection + identifier + date). The caller (route)
+ * is responsible for building absolute URLs — this handler does NOT
+ * assume a URL structure.
+ */
+export async function handleSitemapData(
+	db: Kysely<Database>,
+): Promise<ApiResult<SitemapDataResponse>> {
+	try {
+		// Find all SEO-enabled collections
+		const collections = await db
+			.selectFrom("_emdash_collections")
+			.select(["slug"])
+			.where("has_seo", "=", 1)
+			.execute();
+
+		const entries: SitemapContentEntry[] = [];
+
+		for (const col of collections) {
+			if (entries.length >= SITEMAP_MAX_ENTRIES) break;
+
+			// Validate the slug before using it as a table name identifier.
+			// Should always pass (slugs are validated on creation), but
+			// guards against corrupted DB data.
+			try {
+				validateIdentifier(col.slug, "collection slug");
+			} catch {
+				console.warn(`[SITEMAP] Skipping collection with invalid slug: ${col.slug}`);
+				continue;
+			}
+
+			const tableName = `ec_${col.slug}`;
+			const remaining = SITEMAP_MAX_ENTRIES - entries.length;
+
+			// Query published, non-deleted content.
+			// LEFT JOIN _emdash_seo to check noindex flag.
+			// Content without an SEO row is assumed indexable (default).
+			// Wrapped in try/catch so a missing/broken table doesn't fail the
+			// entire sitemap — we skip that collection and continue.
+			try {
+				const rows = await sql<{
+					slug: string | null;
+					id: string;
+					updated_at: string;
+				}>`
+					SELECT c.slug, c.id, c.updated_at
+					FROM ${sql.ref(tableName)} c
+					LEFT JOIN _emdash_seo s
+						ON s.collection = ${col.slug}
+						AND s.content_id = c.id
+					WHERE c.status = 'published'
+					AND c.deleted_at IS NULL
+					AND (s.seo_no_index IS NULL OR s.seo_no_index = 0)
+					ORDER BY c.updated_at DESC
+					LIMIT ${remaining}
+				`.execute(db);
+
+				for (const row of rows.rows) {
+					entries.push({
+						collection: col.slug,
+						identifier: row.slug || row.id,
+						updatedAt: row.updated_at,
+					});
+				}
+			} catch (err) {
+				// Table missing or query error — skip this collection
+				console.warn(`[SITEMAP] Failed to query collection "${col.slug}":`, err);
+				continue;
+			}
+		}
+
+		return { success: true, data: { entries } };
+	} catch (error) {
+		console.error("[SITEMAP_ERROR]", error);
+		return {
+			success: false,
+			error: { code: "SITEMAP_ERROR", message: "Failed to generate sitemap data" },
+		};
+	}
+}

package/src/api/handlers/settings.ts

@@ -0,0 +1,49 @@
+/**
+ * Settings handlers
+ */
+
+import type { Kysely } from "kysely";
+
+import type { Database } from "../../database/types.js";
+import { getSiteSettingsWithDb, setSiteSettings } from "../../settings/index.js";
+import type { SiteSettings } from "../../settings/types.js";
+import type { Storage } from "../../storage/types.js";
+import type { ApiResult } from "../types.js";
+
+/**
+ * Get all site settings
+ */
+export async function handleSettingsGet(
+	db: Kysely<Database>,
+	storage: Storage | null,
+): Promise<ApiResult<Partial<SiteSettings>>> {
+	try {
+		const settings = await getSiteSettingsWithDb(db, storage);
+		return { success: true, data: settings };
+	} catch {
+		return {
+			success: false,
+			error: { code: "SETTINGS_READ_ERROR", message: "Failed to get settings" },
+		};
+	}
+}
+
+/**
+ * Update site settings
+ */
+export async function handleSettingsUpdate(
+	db: Kysely<Database>,
+	storage: Storage | null,
+	input: Partial<SiteSettings>,
+): Promise<ApiResult<Partial<SiteSettings>>> {
+	try {
+		await setSiteSettings(input, db);
+		const updatedSettings = await getSiteSettingsWithDb(db, storage);
+		return { success: true, data: updatedSettings };
+	} catch {
+		return {
+			success: false,
+			error: { code: "SETTINGS_UPDATE_ERROR", message: "Failed to update settings" },
+		};
+	}
+}