emdash 0.25.1 → 0.27.0

package/src/components/LiveSearch.astro

@@ -34,6 +34,8 @@ export interface Props {
 	limit?: number;
 	/** CSS class for the container */
 	class?: string;
+	/** Inline style for the container */
+	style?: string;
 	/** CSS class for the input */
 	inputClass?: string;
 	/** CSS class for the results container */
@@ -48,6 +50,10 @@ export interface Props {
 	suggestMode?: boolean;
 	/** Expand input width on focus (provide collapsed and expanded widths) */
 	expandOnFocus?: { collapsed: string; expanded: string };
+	/** Search results page to navigate to when pressing Enter without a focused result */
+	searchPage?: string;
+	/** Per-collection URL templates, e.g. { posts: "/blog/:path" } */
+	routeMap?: Record<string, string>;
 }
 
 const {
@@ -57,6 +63,7 @@ const {
 	debounce = 300,
 	limit = 10,
 	class: className = "",
+	style: styleAttr = "",
 	inputClass = "",
 	resultsClass = "",
 	resultClass = "",
@@ -64,6 +71,8 @@ const {
 	autofocus = false,
 	suggestMode = false,
 	expandOnFocus,
+	searchPage = "",
+	routeMap = {},
 } = Astro.props;
 
 const config = {
@@ -74,11 +83,14 @@ const config = {
 	showSnippets,
 	suggestMode,
 	expandOnFocus: expandOnFocus ?? null,
+	searchPage,
+	routeMap,
 };
 ---
 
 <emdash-live-search
 	class:list={["emdash-live-search", className]}
+	style={styleAttr}
 	data-config={JSON.stringify(config)}
 >
 	<input
@@ -109,6 +121,12 @@ const config = {
 </emdash-live-search>
 
 <script>
+	import {
+		buildLiveSearchResultUrl,
+		type LiveSearchRouteMap,
+		type LiveSearchRoutableResult,
+	} from "./live-search-routing.js";
+
 	interface SearchResult {
 		collection: string;
 		id: string;
@@ -121,6 +139,7 @@ const config = {
 	interface Suggestion {
 		collection: string;
 		id: string;
+		slug?: string | null;
 		title: string;
 	}
 
@@ -132,6 +151,8 @@ const config = {
 		showSnippets: boolean;
 		suggestMode: boolean;
 		expandOnFocus: { collapsed: string; expanded: string } | null;
+		searchPage: string;
+		routeMap: LiveSearchRouteMap;
 	}
 
 	class EmDashLiveSearch extends HTMLElement {
@@ -149,6 +170,8 @@ const config = {
 			showSnippets: true,
 			suggestMode: false,
 			expandOnFocus: null,
+			searchPage: "",
+			routeMap: {},
 		};
 		private debounceTimer: ReturnType<typeof setTimeout> | null = null;
 		private abortController: AbortController | null = null;
@@ -268,11 +291,25 @@ const config = {
 					".emdash-live-search-result:focus, .emdash-live-search-result.focused"
 				) as HTMLAnchorElement | null;
 				if (focused?.href) {
+					e.preventDefault();
 					window.location.href = focused.href;
+					return;
+				}
+
+				const query = this.input?.value.trim();
+				if (query && this.config.searchPage) {
+					e.preventDefault();
+					const url = new URL(this.config.searchPage, window.location.origin);
+					url.searchParams.set("q", query);
+					window.location.href = url.toString();
 				}
 			}
 		}
 
+		private buildResultUrl(result: LiveSearchRoutableResult): string {
+			return buildLiveSearchResultUrl(result, this.config.routeMap);
+		}
+
 		private navigateResults(direction: number) {
 			if (!this.resultsList) return;
 
@@ -369,9 +406,7 @@ const config = {
 				const link = clone.querySelector("a");
 
 				if (link) {
-					// Build URL - use slug if available, otherwise id
-					const path = result.slug ?? result.id;
-					link.href = `/${result.collection}/${path}`;
+					link.href = this.buildResultUrl(result);
 
 					// Fill in title
 					const titleEl = link.querySelector(
@@ -430,7 +465,7 @@ const config = {
 				const link = clone.querySelector("a");
 
 				if (link) {
-					link.href = `/${suggestion.collection}/${suggestion.id}`;
+					link.href = this.buildResultUrl(suggestion);
 
 					const titleEl = link.querySelector(
 						".emdash-live-search-result-title"
@@ -456,6 +491,7 @@ const config = {
 
 					link.dataset.id = suggestion.id;
 					link.dataset.collection = suggestion.collection;
+					link.dataset.slug = suggestion.slug ?? "";
 				}
 
 				this.resultsList.appendChild(clone);

package/src/components/live-search-routing.ts

@@ -0,0 +1,30 @@
+export interface LiveSearchRoutableResult {
+	collection: string;
+	id: string;
+	slug?: string | null;
+}
+
+export type LiveSearchRouteMap = Record<string, string>;
+
+function replaceRouteToken(template: string, token: string, value: string): string {
+	return template.split(token).join(value);
+}
+
+export function buildLiveSearchResultUrl(
+	result: LiveSearchRoutableResult,
+	routeMap: LiveSearchRouteMap = {},
+): string {
+	const path = result.slug ?? result.id;
+	const template = routeMap[result.collection];
+
+	if (!template) {
+		return `/${result.collection}/${path}`;
+	}
+
+	return [
+		[":collection", result.collection],
+		[":id", result.id],
+		[":slug", result.slug ?? result.id],
+		[":path", path],
+	].reduce((url, [token, value]) => replaceRouteToken(url, token, value), template);
+}

package/src/database/migrations/036_i18n_menus_and_taxonomies.ts

@@ -199,6 +199,15 @@ async function rebuildTaxonomies(db: Kysely<unknown>, defaultLocale: string): Pr
 		.on("taxonomies")
 		.column("translation_group")
 		.execute();
+	// Dropping the old table dropped idx_taxonomies_parent (from 015); recreate
+	// it here for parity with rebuildMenuItems/rebuildContentTaxonomies. Existing
+	// installs recover it via migration 047.
+	await db.schema
+		.createIndex("idx_taxonomies_parent")
+		.ifNotExists()
+		.on("taxonomies")
+		.column("parent_id")
+		.execute();
 }
 
 async function rebuildTaxonomyDefs(db: Kysely<unknown>, defaultLocale: string): Promise<void> {
@@ -250,27 +259,32 @@ async function rebuildContentTaxonomies(db: Kysely<unknown>): Promise<void> {
 	// is load-bearing — if the translation_group seed ever changes, this needs
 	// an explicit remap *after* `rebuildTaxonomies` runs.
 	const fks = await sql<{ id: number }>`PRAGMA foreign_key_list(content_taxonomies)`.execute(db);
-	if (fks.rows.length === 0) return;
-
-	await sql.raw(`DROP TABLE IF EXISTS "content_taxonomies_new"`).execute(db);
-	await db.schema
-		.createTable("content_taxonomies_new")
-		.addColumn("collection", "text", (c) => c.notNull())
-		.addColumn("entry_id", "text", (c) => c.notNull())
-		.addColumn("taxonomy_id", "text", (c) => c.notNull())
-		.addPrimaryKeyConstraint("content_taxonomies_pk", ["collection", "entry_id", "taxonomy_id"])
-		.execute();
+	if (fks.rows.length > 0) {
+		await sql.raw(`DROP TABLE IF EXISTS "content_taxonomies_new"`).execute(db);
+		await db.schema
+			.createTable("content_taxonomies_new")
+			.addColumn("collection", "text", (c) => c.notNull())
+			.addColumn("entry_id", "text", (c) => c.notNull())
+			.addColumn("taxonomy_id", "text", (c) => c.notNull())
+			.addPrimaryKeyConstraint("content_taxonomies_pk", ["collection", "entry_id", "taxonomy_id"])
+			.execute();
 
-	await sql`
-		INSERT OR IGNORE INTO content_taxonomies_new (collection, entry_id, taxonomy_id)
-		SELECT collection, entry_id, taxonomy_id FROM content_taxonomies
-	`.execute(db);
+		await sql`
+			INSERT OR IGNORE INTO content_taxonomies_new (collection, entry_id, taxonomy_id)
+			SELECT collection, entry_id, taxonomy_id FROM content_taxonomies
+		`.execute(db);
 
-	await db.schema.dropTable("content_taxonomies").execute();
-	await sql`ALTER TABLE content_taxonomies_new RENAME TO content_taxonomies`.execute(db);
+		await db.schema.dropTable("content_taxonomies").execute();
+		await sql`ALTER TABLE content_taxonomies_new RENAME TO content_taxonomies`.execute(db);
+	}
 
-	// SQLite drops indexes when the underlying table is dropped. Restore the
-	// taxonomy_id index from migration 015.
+	// Recreate the taxonomy_id index from migration 015 unconditionally, OUTSIDE
+	// the FK-presence guard above. The rebuild both strips the FK and drops the
+	// old table's indexes, but D1 auto-commits each DDL statement — so a first
+	// run that failed after the drop leaves the table with no FK and no index.
+	// The retry then finds zero FKs and skips the rebuild; if the index recreate
+	// lived inside that guard it would never run and the index would be lost for
+	// good (#1701). `IF NOT EXISTS` keeps this a no-op once present.
 	await sql`CREATE INDEX IF NOT EXISTS idx_content_taxonomies_term ON content_taxonomies(taxonomy_id)`.execute(
 		db,
 	);
@@ -569,6 +583,13 @@ async function rebuildTaxonomiesDown(db: Kysely<unknown>): Promise<void> {
 	await db.schema.dropTable("taxonomies").execute();
 	await sql`ALTER TABLE taxonomies_old RENAME TO taxonomies`.execute(db);
 	await db.schema.createIndex("idx_taxonomies_name").on("taxonomies").column("name").execute();
+	// Restore the pre-036 (migration 015) parent index so the rollback is faithful.
+	await db.schema
+		.createIndex("idx_taxonomies_parent")
+		.ifNotExists()
+		.on("taxonomies")
+		.column("parent_id")
+		.execute();
 }
 
 async function rebuildTaxonomyDefsDown(db: Kysely<unknown>): Promise<void> {

package/src/database/migrations/046_media_usage_index.ts

@@ -0,0 +1,115 @@
+import type { Kysely } from "kysely";
+
+import { currentTimestamp } from "../dialect-helpers.js";
+
+/**
+ * Internal media usage projection tables.
+ *
+ * This migration is DDL-only by design: no backfill, no runtime media/indexing
+ * imports, and no content-table scans. Production rows are introduced by later
+ * phases once the central snapshot/indexer path is reviewed.
+ */
+export async function up(db: Kysely<unknown>): Promise<void> {
+	await db.schema
+		.createTable("_emdash_media_usage_sources")
+		.ifNotExists()
+		.addColumn("source_key", "text", (c) => c.primaryKey())
+		.addColumn("source_type", "text", (c) => c.notNull())
+		.addColumn("collection_slug", "text")
+		.addColumn("content_id", "text")
+		.addColumn("source_variant", "text", (c) => c.notNull())
+		.addColumn("locale", "text")
+		.addColumn("translation_group", "text")
+		.addColumn("content_slug", "text")
+		.addColumn("content_title", "text")
+		.addColumn("content_status", "text")
+		.addColumn("content_scheduled_at", "text")
+		.addColumn("content_deleted_at", "text")
+		.addColumn("revision_id", "text")
+		.addColumn("current_generation", "text", (c) => c.notNull())
+		.addColumn("schema_version", "integer", (c) => c.notNull().defaultTo(1))
+		.addColumn("indexed_at", "text", (c) => c.notNull().defaultTo(currentTimestamp(db)))
+		.addColumn("created_at", "text", (c) => c.defaultTo(currentTimestamp(db)))
+		.addColumn("updated_at", "text", (c) => c.defaultTo(currentTimestamp(db)))
+		.execute();
+
+	await db.schema
+		.createIndex("idx__emdash_media_usage_sources_content")
+		.ifNotExists()
+		.on("_emdash_media_usage_sources")
+		.columns(["source_type", "collection_slug", "content_id"])
+		.execute();
+	await db.schema
+		.createIndex("idx__emdash_media_usage_sources_variant")
+		.ifNotExists()
+		.on("_emdash_media_usage_sources")
+		.columns(["source_type", "source_variant"])
+		.execute();
+	await db.schema
+		.createIndex("idx__emdash_media_usage_sources_locale")
+		.ifNotExists()
+		.on("_emdash_media_usage_sources")
+		.columns(["collection_slug", "locale"])
+		.execute();
+	await db.schema
+		.createIndex("idx__emdash_media_usage_sources_deleted")
+		.ifNotExists()
+		.on("_emdash_media_usage_sources")
+		.column("content_deleted_at")
+		.execute();
+	await db.schema
+		.createIndex("idx__emdash_media_usage_sources_translation_group")
+		.ifNotExists()
+		.on("_emdash_media_usage_sources")
+		.columns(["collection_slug", "translation_group"])
+		.execute();
+
+	await db.schema
+		.createTable("_emdash_media_usage")
+		.ifNotExists()
+		.addColumn("id", "text", (c) => c.primaryKey())
+		.addColumn("source_key", "text", (c) => c.notNull())
+		.addColumn("generation", "text", (c) => c.notNull())
+		.addColumn("field_slug", "text", (c) => c.notNull())
+		.addColumn("field_path", "text", (c) => c.notNull())
+		.addColumn("occurrence_index", "integer", (c) => c.notNull().defaultTo(0))
+		.addColumn("reference_type", "text", (c) => c.notNull())
+		.addColumn("media_id", "text")
+		.addColumn("provider", "text", (c) => c.notNull().defaultTo("local"))
+		.addColumn("provider_asset_id", "text", (c) => c.notNull())
+		.addColumn("media_kind", "text")
+		.addColumn("mime_type", "text")
+		.addColumn("created_at", "text", (c) => c.defaultTo(currentTimestamp(db)))
+		.execute();
+
+	await db.schema
+		.createIndex("idx__emdash_media_usage_unique_occurrence")
+		.ifNotExists()
+		.unique()
+		.on("_emdash_media_usage")
+		.columns(["source_key", "generation", "field_path", "occurrence_index"])
+		.execute();
+	await db.schema
+		.createIndex("idx__emdash_media_usage_media_id")
+		.ifNotExists()
+		.on("_emdash_media_usage")
+		.column("media_id")
+		.execute();
+	await db.schema
+		.createIndex("idx__emdash_media_usage_provider_asset")
+		.ifNotExists()
+		.on("_emdash_media_usage")
+		.columns(["provider", "provider_asset_id"])
+		.execute();
+	await db.schema
+		.createIndex("idx__emdash_media_usage_source_generation")
+		.ifNotExists()
+		.on("_emdash_media_usage")
+		.columns(["source_key", "generation"])
+		.execute();
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	await db.schema.dropTable("_emdash_media_usage").ifExists().execute();
+	await db.schema.dropTable("_emdash_media_usage_sources").ifExists().execute();
+}

package/src/database/migrations/047_restore_taxonomy_parent_index.ts

@@ -0,0 +1,29 @@
+import type { Kysely } from "kysely";
+
+/**
+ * Restore `idx_taxonomies_parent` on `taxonomies(parent_id)` (#1665).
+ *
+ * Migration 015 created this index, but 036's SQLite table rebuild
+ * (`taxonomies_new` → drop → rename) dropped every index attached to the old
+ * table and only recreated `name`/`locale`/`translation_group`. The parent
+ * index — which backs hierarchical (parent/child) lookups — was silently lost
+ * on any install migrated through 036. The Postgres path in 036 alters the
+ * table in place and keeps its indexes, so it is unaffected; `ifNotExists`
+ * makes this a no-op there.
+ *
+ * Forward-only: 036 has already shipped, so existing installs only recover the
+ * index here. Fresh installs also get it in 036's rebuild for parity with the
+ * other rebuilt tables, making this a no-op for them.
+ */
+export async function up(db: Kysely<unknown>): Promise<void> {
+	await db.schema
+		.createIndex("idx_taxonomies_parent")
+		.ifNotExists()
+		.on("taxonomies")
+		.column("parent_id")
+		.execute();
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	await db.schema.dropIndex("idx_taxonomies_parent").ifExists().execute();
+}

package/src/database/migrations/048_restore_content_taxonomies_term_index.ts

@@ -0,0 +1,32 @@
+import type { Kysely } from "kysely";
+
+/**
+ * Restore `idx_content_taxonomies_term` on `content_taxonomies(taxonomy_id)` (#1701).
+ *
+ * Migration 015 created this index. 036's SQLite/D1 table rebuild recreated it,
+ * but the recreate was gated behind an FK-presence early-return: if a first run
+ * committed the rebuild (stripping the FK and dropping the old index) and then
+ * failed before the recreate, the retry saw zero FKs, skipped the whole body,
+ * and never restored the index — while 036 was still recorded as applied. The
+ * result was an install missing only this one index, with no forward migration
+ * to recover it (the sibling `idx_taxonomies_parent` case was fixed by 047).
+ *
+ * 036 has since been fixed to recreate the index unconditionally, so fresh
+ * installs are fine. This recovers the index on installs that hit the trap
+ * before that fix. The Postgres path in 036 alters in place and keeps its
+ * indexes, so it is unaffected; `ifNotExists` makes this a no-op there.
+ *
+ * Forward-only.
+ */
+export async function up(db: Kysely<unknown>): Promise<void> {
+	await db.schema
+		.createIndex("idx_content_taxonomies_term")
+		.ifNotExists()
+		.on("content_taxonomies")
+		.column("taxonomy_id")
+		.execute();
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	await db.schema.dropIndex("idx_content_taxonomies_term").ifExists().execute();
+}

package/src/database/migrations/runner.ts

@@ -47,6 +47,9 @@ import * as m042 from "./042_byline_fields.js";
 import * as m043 from "./043_content_references.js";
 import * as m044 from "./044_comment_reactions.js";
 import * as m045 from "./045_taxonomy_parent_group.js";
+import * as m046 from "./046_media_usage_index.js";
+import * as m047 from "./047_restore_taxonomy_parent_index.js";
+import * as m048 from "./048_restore_content_taxonomies_term_index.js";
 
 const MIGRATIONS: Readonly<Record<string, Migration>> = Object.freeze({
 	"001_initial": m001,
@@ -93,6 +96,9 @@ const MIGRATIONS: Readonly<Record<string, Migration>> = Object.freeze({
 	"043_content_references": m043,
 	"044_comment_reactions": m044,
 	"045_taxonomy_parent_group": m045,
+	"046_media_usage_index": m046,
+	"047_restore_taxonomy_parent_index": m047,
+	"048_restore_content_taxonomies_term_index": m048,
 });
 
 /** Total number of registered migrations. Exported for use in tests. */