emdash 0.0.0-b → 0.0.2

package/src/database/repositories/seo.ts

@@ -0,0 +1,176 @@
+import { sql, type Kysely } from "kysely";
+
+import type { Database } from "../types.js";
+import type { ContentSeo, ContentSeoInput } from "./types.js";
+
+/** Default SEO values for content without an explicit SEO row */
+const SEO_DEFAULTS: ContentSeo = {
+	title: null,
+	description: null,
+	image: null,
+	canonical: null,
+	noIndex: false,
+};
+
+/**
+ * Returns true if the input has at least one explicitly-set SEO field.
+ * Used to skip no-op upserts when callers pass `{ seo: {} }`.
+ */
+function hasAnyField(input: ContentSeoInput): boolean {
+	return (
+		input.title !== undefined ||
+		input.description !== undefined ||
+		input.image !== undefined ||
+		input.canonical !== undefined ||
+		input.noIndex !== undefined
+	);
+}
+
+/**
+ * Repository for SEO metadata stored in `_emdash_seo`.
+ *
+ * SEO data lives in a separate table keyed by (collection, content_id).
+ * Only collections with `has_seo = 1` should use this — callers are
+ * responsible for checking the flag before reading/writing.
+ */
+export class SeoRepository {
+	constructor(private db: Kysely<Database>) {}
+
+	/**
+	 * Get SEO data for a content item. Returns null defaults if no row exists.
+	 */
+	async get(collection: string, contentId: string): Promise<ContentSeo> {
+		const row = await this.db
+			.selectFrom("_emdash_seo")
+			.selectAll()
+			.where("collection", "=", collection)
+			.where("content_id", "=", contentId)
+			.executeTakeFirst();
+
+		if (!row) {
+			return { ...SEO_DEFAULTS };
+		}
+
+		return {
+			title: row.seo_title ?? null,
+			description: row.seo_description ?? null,
+			image: row.seo_image ?? null,
+			canonical: row.seo_canonical ?? null,
+			noIndex: row.seo_no_index === 1,
+		};
+	}
+
+	/**
+	 * Get SEO data for multiple content items in a single query.
+	 * Returns a Map keyed by content_id. Items without SEO rows get defaults.
+	 */
+	async getMany(collection: string, contentIds: string[]): Promise<Map<string, ContentSeo>> {
+		const result = new Map<string, ContentSeo>();
+
+		if (contentIds.length === 0) return result;
+
+		// Batch query — single SELECT with IN clause
+		const rows = await this.db
+			.selectFrom("_emdash_seo")
+			.selectAll()
+			.where("collection", "=", collection)
+			.where("content_id", "in", contentIds)
+			.execute();
+
+		// Index fetched rows by content_id
+		const rowMap = new Map(rows.map((r) => [r.content_id, r]));
+
+		for (const id of contentIds) {
+			const row = rowMap.get(id);
+			if (row) {
+				result.set(id, {
+					title: row.seo_title ?? null,
+					description: row.seo_description ?? null,
+					image: row.seo_image ?? null,
+					canonical: row.seo_canonical ?? null,
+					noIndex: row.seo_no_index === 1,
+				});
+			} else {
+				result.set(id, { ...SEO_DEFAULTS });
+			}
+		}
+
+		return result;
+	}
+
+	/**
+	 * Upsert SEO data for a content item using INSERT ON CONFLICT DO UPDATE
+	 * for atomicity. Skips no-op writes when input has no fields set.
+	 */
+	async upsert(collection: string, contentId: string, input: ContentSeoInput): Promise<ContentSeo> {
+		// Skip no-op: empty input (e.g., `{ seo: {} }` from form libs)
+		if (!hasAnyField(input)) {
+			return this.get(collection, contentId);
+		}
+
+		const now = new Date().toISOString();
+
+		// Use INSERT ON CONFLICT for atomic upsert — avoids TOCTOU race
+		// where two concurrent requests both see "no row" and both try INSERT.
+		//
+		// On conflict, we use COALESCE(excluded.col, current.col) so that
+		// only explicitly-provided fields overwrite existing values.
+		await sql`
+			INSERT INTO _emdash_seo (
+				collection, content_id,
+				seo_title, seo_description, seo_image, seo_canonical, seo_no_index,
+				created_at, updated_at
+			) VALUES (
+				${collection}, ${contentId},
+				${input.title ?? null}, ${input.description ?? null},
+				${input.image ?? null}, ${input.canonical ?? null},
+				${input.noIndex ? 1 : 0},
+				${now}, ${now}
+			)
+			ON CONFLICT (collection, content_id) DO UPDATE SET
+				seo_title = ${input.title !== undefined ? sql`${input.title}` : sql`_emdash_seo.seo_title`},
+				seo_description = ${input.description !== undefined ? sql`${input.description}` : sql`_emdash_seo.seo_description`},
+				seo_image = ${input.image !== undefined ? sql`${input.image}` : sql`_emdash_seo.seo_image`},
+				seo_canonical = ${input.canonical !== undefined ? sql`${input.canonical}` : sql`_emdash_seo.seo_canonical`},
+				seo_no_index = ${input.noIndex !== undefined ? sql`${input.noIndex ? 1 : 0}` : sql`_emdash_seo.seo_no_index`},
+				updated_at = ${now}
+		`.execute(this.db);
+
+		return this.get(collection, contentId);
+	}
+
+	/**
+	 * Delete SEO data for a content item.
+	 */
+	async delete(collection: string, contentId: string): Promise<void> {
+		await this.db
+			.deleteFrom("_emdash_seo")
+			.where("collection", "=", collection)
+			.where("content_id", "=", contentId)
+			.execute();
+	}
+
+	/**
+	 * Copy SEO data from one content item to another.
+	 * Used by duplicate. Clears canonical (it pointed to the original).
+	 */
+	async copyForDuplicate(collection: string, sourceId: string, targetId: string): Promise<void> {
+		const source = await this.get(collection, sourceId);
+
+		// Only write if there's actual SEO data worth copying
+		if (
+			source.title !== null ||
+			source.description !== null ||
+			source.image !== null ||
+			source.noIndex
+		) {
+			await this.upsert(collection, targetId, {
+				title: source.title,
+				description: source.description,
+				image: source.image,
+				canonical: null, // Don't copy canonical — it pointed to the original
+				noIndex: source.noIndex,
+			});
+		}
+	}
+}

package/src/database/repositories/taxonomy.ts

@@ -0,0 +1,294 @@
+import type { Kysely } from "kysely";
+import { ulid } from "ulidx";
+
+import type { Database, TaxonomyTable, ContentTaxonomyTable } from "../types.js";
+
+export interface Taxonomy {
+	id: string;
+	name: string;
+	slug: string;
+	label: string;
+	parentId: string | null;
+	data: Record<string, unknown> | null;
+}
+
+export interface CreateTaxonomyInput {
+	name: string;
+	slug: string;
+	label: string;
+	parentId?: string;
+	data?: Record<string, unknown>;
+}
+
+export interface UpdateTaxonomyInput {
+	slug?: string;
+	label?: string;
+	parentId?: string | null;
+	data?: Record<string, unknown>;
+}
+
+/**
+ * Taxonomy repository for categories, tags, and other classification
+ *
+ * Taxonomies are hierarchical (via parentId) and can be attached to content entries.
+ */
+export class TaxonomyRepository {
+	constructor(private db: Kysely<Database>) {}
+
+	/**
+	 * Create a new taxonomy term
+	 */
+	async create(input: CreateTaxonomyInput): Promise<Taxonomy> {
+		const id = ulid();
+
+		const row: TaxonomyTable = {
+			id,
+			name: input.name,
+			slug: input.slug,
+			label: input.label,
+			parent_id: input.parentId ?? null,
+			data: input.data ? JSON.stringify(input.data) : null,
+		};
+
+		await this.db.insertInto("taxonomies").values(row).execute();
+
+		const taxonomy = await this.findById(id);
+		if (!taxonomy) {
+			throw new Error("Failed to create taxonomy");
+		}
+		return taxonomy;
+	}
+
+	/**
+	 * Find taxonomy by ID
+	 */
+	async findById(id: string): Promise<Taxonomy | null> {
+		const row = await this.db
+			.selectFrom("taxonomies")
+			.selectAll()
+			.where("id", "=", id)
+			.executeTakeFirst();
+
+		return row ? this.rowToTaxonomy(row) : null;
+	}
+
+	/**
+	 * Find taxonomy by name and slug (unique constraint)
+	 */
+	async findBySlug(name: string, slug: string): Promise<Taxonomy | null> {
+		const row = await this.db
+			.selectFrom("taxonomies")
+			.selectAll()
+			.where("name", "=", name)
+			.where("slug", "=", slug)
+			.executeTakeFirst();
+
+		return row ? this.rowToTaxonomy(row) : null;
+	}
+
+	/**
+	 * Get all terms for a taxonomy (e.g., all categories)
+	 */
+	async findByName(name: string, options: { parentId?: string | null } = {}): Promise<Taxonomy[]> {
+		let query = this.db
+			.selectFrom("taxonomies")
+			.selectAll()
+			.where("name", "=", name)
+			.orderBy("label", "asc");
+
+		if (options.parentId !== undefined) {
+			if (options.parentId === null) {
+				query = query.where("parent_id", "is", null);
+			} else {
+				query = query.where("parent_id", "=", options.parentId);
+			}
+		}
+
+		const rows = await query.execute();
+		return rows.map((row) => this.rowToTaxonomy(row));
+	}
+
+	/**
+	 * Get children of a taxonomy term
+	 */
+	async findChildren(parentId: string): Promise<Taxonomy[]> {
+		const rows = await this.db
+			.selectFrom("taxonomies")
+			.selectAll()
+			.where("parent_id", "=", parentId)
+			.orderBy("label", "asc")
+			.execute();
+
+		return rows.map((row) => this.rowToTaxonomy(row));
+	}
+
+	/**
+	 * Update a taxonomy term
+	 */
+	async update(id: string, input: UpdateTaxonomyInput): Promise<Taxonomy | null> {
+		const existing = await this.findById(id);
+		if (!existing) return null;
+
+		const updates: Partial<TaxonomyTable> = {};
+		if (input.slug !== undefined) updates.slug = input.slug;
+		if (input.label !== undefined) updates.label = input.label;
+		if (input.parentId !== undefined) updates.parent_id = input.parentId;
+		if (input.data !== undefined) updates.data = JSON.stringify(input.data);
+
+		if (Object.keys(updates).length > 0) {
+			await this.db.updateTable("taxonomies").set(updates).where("id", "=", id).execute();
+		}
+
+		return this.findById(id);
+	}
+
+	/**
+	 * Delete a taxonomy term
+	 */
+	async delete(id: string): Promise<boolean> {
+		// First remove any content associations
+		await this.db.deleteFrom("content_taxonomies").where("taxonomy_id", "=", id).execute();
+
+		const result = await this.db.deleteFrom("taxonomies").where("id", "=", id).executeTakeFirst();
+
+		return (result.numDeletedRows ?? 0) > 0;
+	}
+
+	// --- Content-Taxonomy Junction ---
+
+	/**
+	 * Attach a taxonomy term to a content entry
+	 */
+	async attachToEntry(collection: string, entryId: string, taxonomyId: string): Promise<void> {
+		const row: ContentTaxonomyTable = {
+			collection,
+			entry_id: entryId,
+			taxonomy_id: taxonomyId,
+		};
+
+		// Use INSERT OR IGNORE pattern for idempotency
+		await this.db
+			.insertInto("content_taxonomies")
+			.values(row)
+			.onConflict((oc) => oc.doNothing())
+			.execute();
+	}
+
+	/**
+	 * Detach a taxonomy term from a content entry
+	 */
+	async detachFromEntry(collection: string, entryId: string, taxonomyId: string): Promise<void> {
+		await this.db
+			.deleteFrom("content_taxonomies")
+			.where("collection", "=", collection)
+			.where("entry_id", "=", entryId)
+			.where("taxonomy_id", "=", taxonomyId)
+			.execute();
+	}
+
+	/**
+	 * Get all taxonomy terms for a content entry
+	 */
+	async getTermsForEntry(
+		collection: string,
+		entryId: string,
+		taxonomyName?: string,
+	): Promise<Taxonomy[]> {
+		let query = this.db
+			.selectFrom("content_taxonomies")
+			.innerJoin("taxonomies", "taxonomies.id", "content_taxonomies.taxonomy_id")
+			.selectAll("taxonomies")
+			.where("content_taxonomies.collection", "=", collection)
+			.where("content_taxonomies.entry_id", "=", entryId);
+
+		if (taxonomyName) {
+			query = query.where("taxonomies.name", "=", taxonomyName);
+		}
+
+		const rows = await query.execute();
+		return rows.map((row) => this.rowToTaxonomy(row));
+	}
+
+	/**
+	 * Set all taxonomy terms for a content entry (replaces existing)
+	 * Uses batch operations to avoid N+1 queries.
+	 */
+	async setTermsForEntry(
+		collection: string,
+		entryId: string,
+		taxonomyName: string,
+		taxonomyIds: string[],
+	): Promise<void> {
+		// Get current terms of this taxonomy type
+		const current = await this.getTermsForEntry(collection, entryId, taxonomyName);
+		const currentIds = new Set(current.map((t) => t.id));
+		const newIds = new Set(taxonomyIds);
+
+		// Batch remove terms no longer present
+		const toRemove = current.filter((t) => !newIds.has(t.id)).map((t) => t.id);
+		if (toRemove.length > 0) {
+			await this.db
+				.deleteFrom("content_taxonomies")
+				.where("collection", "=", collection)
+				.where("entry_id", "=", entryId)
+				.where("taxonomy_id", "in", toRemove)
+				.execute();
+		}
+
+		// Batch add new terms
+		const toAdd = taxonomyIds.filter((id) => !currentIds.has(id));
+		if (toAdd.length > 0) {
+			await this.db
+				.insertInto("content_taxonomies")
+				.values(
+					toAdd.map((taxonomy_id) => ({
+						collection,
+						entry_id: entryId,
+						taxonomy_id,
+					})),
+				)
+				.onConflict((oc) => oc.doNothing())
+				.execute();
+		}
+	}
+
+	/**
+	 * Remove all taxonomy associations for an entry (use when entry is deleted)
+	 */
+	async clearEntryTerms(collection: string, entryId: string): Promise<number> {
+		const result = await this.db
+			.deleteFrom("content_taxonomies")
+			.where("collection", "=", collection)
+			.where("entry_id", "=", entryId)
+			.executeTakeFirst();
+
+		return Number(result.numDeletedRows ?? 0);
+	}
+
+	/**
+	 * Count entries that have a specific taxonomy term
+	 */
+	async countEntriesWithTerm(taxonomyId: string): Promise<number> {
+		const result = await this.db
+			.selectFrom("content_taxonomies")
+			.select((eb) => eb.fn.count("entry_id").as("count"))
+			.where("taxonomy_id", "=", taxonomyId)
+			.executeTakeFirst();
+
+		return Number(result?.count || 0);
+	}
+
+	/**
+	 * Convert database row to Taxonomy object
+	 */
+	private rowToTaxonomy(row: TaxonomyTable): Taxonomy {
+		return {
+			id: row.id,
+			name: row.name,
+			slug: row.slug,
+			label: row.label,
+			parentId: row.parent_id,
+			data: row.data ? JSON.parse(row.data) : null,
+		};
+	}
+}

package/src/database/repositories/types.ts

@@ -0,0 +1,132 @@
+import { encodeBase64, decodeBase64 } from "../../utils/base64.js";
+
+export interface CreateContentInput {
+	type: string;
+	slug?: string | null;
+	data: Record<string, unknown>;
+	status?: string;
+	authorId?: string;
+	primaryBylineId?: string | null;
+	locale?: string;
+	translationOf?: string;
+	publishedAt?: string | null;
+}
+
+export interface UpdateContentInput {
+	data?: Record<string, unknown>;
+	status?: string;
+	slug?: string | null;
+	publishedAt?: string | null;
+	scheduledAt?: string | null;
+	authorId?: string | null;
+	primaryBylineId?: string | null;
+}
+
+/** SEO fields for content items */
+export interface ContentSeo {
+	title: string | null;
+	description: string | null;
+	image: string | null;
+	canonical: string | null;
+	noIndex: boolean;
+}
+
+/** Input for updating SEO fields on content */
+export interface ContentSeoInput {
+	title?: string | null;
+	description?: string | null;
+	image?: string | null;
+	canonical?: string | null;
+	noIndex?: boolean;
+}
+
+export interface BylineSummary {
+	id: string;
+	slug: string;
+	displayName: string;
+	bio: string | null;
+	avatarMediaId: string | null;
+	websiteUrl: string | null;
+	userId: string | null;
+	isGuest: boolean;
+	createdAt: string;
+	updatedAt: string;
+}
+
+export interface ContentBylineCredit {
+	byline: BylineSummary;
+	sortOrder: number;
+	roleLabel: string | null;
+	/** Whether this credit was explicitly assigned or inferred from authorId */
+	source?: "explicit" | "inferred";
+}
+
+export interface FindManyOptions {
+	where?: {
+		status?: string;
+		authorId?: string;
+		locale?: string;
+	};
+	orderBy?: {
+		field: string;
+		direction: "asc" | "desc";
+	};
+	limit?: number;
+	cursor?: string; // Base64-encoded JSON: {orderValue: string, id: string}
+}
+
+export interface FindManyResult<T> {
+	items: T[];
+	nextCursor?: string; // Base64-encoded JSON: {orderValue: string, id: string}
+}
+
+/** Encode a cursor from order value + id */
+export function encodeCursor(orderValue: string, id: string): string {
+	return encodeBase64(JSON.stringify({ orderValue, id }));
+}
+
+/** Decode a cursor to order value + id. Returns null if invalid. */
+export function decodeCursor(cursor: string): { orderValue: string; id: string } | null {
+	try {
+		const parsed = JSON.parse(decodeBase64(cursor));
+		if (typeof parsed.orderValue === "string" && typeof parsed.id === "string") {
+			return parsed;
+		}
+		return null;
+	} catch {
+		return null;
+	}
+}
+
+export interface ContentItem {
+	id: string;
+	type: string;
+	slug: string | null;
+	status: string;
+	data: Record<string, unknown>;
+	authorId: string | null;
+	primaryBylineId: string | null;
+	byline?: BylineSummary | null;
+	bylines?: ContentBylineCredit[];
+	createdAt: string;
+	updatedAt: string;
+	publishedAt: string | null;
+	scheduledAt: string | null;
+	liveRevisionId: string | null;
+	draftRevisionId: string | null;
+	version: number;
+	locale: string | null;
+	translationGroup: string | null;
+	/** SEO metadata — only populated for collections with `has_seo` enabled */
+	seo?: ContentSeo;
+}
+
+export class EmDashValidationError extends Error {
+	constructor(
+		message: string,
+		public details?: unknown,
+	) {
+		super(message);
+		this.name = "EmDashValidationError";
+	}
+}