emdash 0.33.0 → 0.35.0

package/src/taxonomies/index.ts

@@ -6,11 +6,15 @@
  * `i18n/resolve.ts`).
  *
  * Because `content_taxonomies.taxonomy_id` stores the translation_group (not a
- * specific term id), the joins here are `taxonomies.translation_group =
- * content_taxonomies.taxonomy_id` + filter by `taxonomies.locale`, which picks
- * the right per-locale term.
+ * specific term id), and `entry_id` stores the content translation_group, one
+ * assignment resolves to the requested locale on both sides.
  */
 
+import { sql, type Kysely } from "kysely";
+
+import type { Database } from "../database/types.js";
+import { validateIdentifier } from "../database/validate.js";
+import { getI18nConfig } from "../i18n/config.js";
 import { resolveLocale, resolveLocaleChain } from "../i18n/resolve.js";
 import { getDb, resetTaxonomyNamesCache } from "../loader.js";
 import {
@@ -40,6 +44,55 @@ export interface TaxonomyTermsOptions extends TaxonomyQueryOptions {
 	includeCounts?: boolean;
 }
 
+interface EntryTermRow {
+	entry_id: string;
+	id: string;
+	name: string;
+	slug: string;
+	label: string;
+	parent_id: string | null;
+	locale: string;
+	translation_group: string | null;
+}
+
+async function selectEntryTermRows(
+	db: Kysely<Database>,
+	collection: string,
+	entryIds: string[],
+	taxonomyName?: string,
+	locale?: string,
+): Promise<EntryTermRow[]> {
+	validateIdentifier(collection, "collection slug");
+	const tableName = `ec_${collection}`;
+	const preferredLocale = locale ? sql`${locale}` : sql`content.locale`;
+	const defaultLocale = getI18nConfig()?.defaultLocale ?? "en";
+	const result = await sql<EntryTermRow>`
+		SELECT content.id AS entry_id,
+			coalesce(exact_term.id, default_term.id) AS id,
+			coalesce(exact_term.name, default_term.name) AS name,
+			coalesce(exact_term.slug, default_term.slug) AS slug,
+			coalesce(exact_term.label, default_term.label) AS label,
+			coalesce(exact_term.parent_id, default_term.parent_id) AS parent_id,
+			coalesce(exact_term.locale, default_term.locale) AS locale,
+			coalesce(exact_term.translation_group, default_term.translation_group) AS translation_group
+		FROM ${sql.ref(tableName)} AS content
+		INNER JOIN content_taxonomies AS pivot
+			ON pivot.entry_id = content.translation_group
+			AND pivot.collection = ${collection}
+		LEFT JOIN taxonomies AS exact_term
+			ON exact_term.translation_group = pivot.taxonomy_id
+			AND exact_term.locale = ${preferredLocale}
+		LEFT JOIN taxonomies AS default_term
+			ON default_term.translation_group = pivot.taxonomy_id
+			AND default_term.locale = ${defaultLocale}
+		WHERE content.id IN (${sql.join(entryIds.map((id) => sql`${id}`))})
+			AND coalesce(exact_term.id, default_term.id) IS NOT NULL
+			${taxonomyName ? sql`AND coalesce(exact_term.name, default_term.name) = ${taxonomyName}` : sql``}
+		ORDER BY coalesce(exact_term.label, default_term.label) ASC
+	`.execute(db);
+	return result.rows;
+}
+
 /** Invalidate cached taxonomy term data and any content that hydrates terms. */
 export function invalidateTermCache(): void {
 	invalidateTaxonomyObjectCache();
@@ -51,10 +104,9 @@ export function invalidateTermCache(): void {
  * Taxonomy *definitions* (the "category"/"tag" taxonomies themselves, not
  * their terms) are read on every public render that hydrates entry terms —
  * `getAllTermsForEntries` → `getCollectionTaxonomyNames` → `getTaxonomyDefs` —
- * but change extremely rarely: they're created via the admin API or applied
- * from a seed, and there is no edit/delete-def path. Caching them across the
- * isolate lifetime drops the per-render `SELECT * FROM _emdash_taxonomy_defs`
- * to once-per-isolate.
+ * but change extremely rarely: they're written only by the admin API and by
+ * seed application. Caching them across the isolate lifetime drops the
+ * per-render `SELECT * FROM _emdash_taxonomy_defs` to once-per-isolate.
  *
  * Stored on globalThis behind a Symbol key (same pattern as
  * `settings/index.ts`) so the bundler duplicating this module across SSR
@@ -89,8 +141,8 @@ const defsHolder: TaxonomyDefsHolder =
 /**
  * Invalidate the isolate-wide taxonomy-definitions cache (and the related
  * loader taxonomy-names cache). Called from every taxonomy-def write path
- * (`handleTaxonomyCreate`, seed application). Other isolates refresh on their
- * next recycle — staleness bounded by isolate lifetime.
+ * (`handleTaxonomyCreate`/`Update`/`Delete`, seed application). Other isolates
+ * refresh on their next recycle — staleness bounded by isolate lifetime.
  */
 export function invalidateTaxonomyDefsCache(): void {
 	defsHolder.version++;
@@ -261,7 +313,7 @@ export async function getTaxonomyTerms(
 	// The two are independent, so run them concurrently to save a round trip.
 	const [terms, counts] = await Promise.all([
 		getTermList(def, locale),
-		getVisibleTermCounts(def.name, def.collections),
+		getVisibleTermCounts(def.name, def.collections, locale),
 	]);
 	return withCounts(terms, counts);
 }
@@ -334,28 +386,30 @@ async function loadTaxonomyTerms(
 
 /**
  * Per-translation-group visible-usage counts for one taxonomy, in a single
- * round-trip (see `fetchVisibleTermCounts`). Counts are locale-independent
- * (the pivot stores translation_group), and the request-cached map is shared
- * by every consumer in the render — the widget (`getTaxonomyTerms`) and the
- * single-term page (`getTerm`) never issue separate count queries.
+ * round-trip (see `fetchVisibleTermCounts`). The pivot identity is the
+ * translation group, while entry rows are scoped to the resolved locale.
+ * Request and object cache keys include that locale so translated views never
+ * reuse each other's visible counts.
  */
 function getVisibleTermCounts(
 	taxonomyName: string,
 	collections: string[],
+	locale?: string,
 ): Promise<Map<string, number>> {
 	// The collection scope is part of the key: per-locale rows of the same def
 	// can drift in their declared collections, and a caller may pass a narrower
 	// scope. Identical inputs (the widget + term-page hot path) still share one
 	// entry.
 	const scope = [...new Set(collections)].toSorted().join(",");
-	return requestCached(`taxonomy-term-counts:${taxonomyName}:${scope}`, async () => {
+	const localeScope = locale ?? "*";
+	return requestCached(`taxonomy-term-counts:${taxonomyName}:${scope}:${localeScope}`, async () => {
 		// A Map is not JSON-representable — cache the entries, rebuild on read.
 		const entries = await cachedQuery({
 			namespace: termCountNamespaces(collections),
-			key: `termCounts:${taxonomyName}:${scope}`,
+			key: `termCounts:${taxonomyName}:${scope}:${localeScope}`,
 			load: async (): Promise<Array<[string, number]>> => {
 				const db = await getDb();
-				return [...(await fetchVisibleTermCounts(db, taxonomyName, collections))];
+				return [...(await fetchVisibleTermCounts(db, taxonomyName, collections, locale))];
 			},
 		});
 		return new Map(entries);
@@ -430,7 +484,7 @@ async function loadTerm(
 	// databases. The counts map is request-cached per taxonomy — on a page
 	// that also renders the taxonomy widget it's a free Map lookup.
 	const [counts, childRows] = await Promise.all([
-		getVisibleTermCounts(taxonomyName, collections),
+		getVisibleTermCounts(taxonomyName, collections, chain[0] ?? row.locale),
 		childrenQuery.execute(),
 	]);
 	const count = counts.get(row.translation_group ?? row.id) ?? 0;
@@ -461,8 +515,8 @@ async function loadTerm(
 }
 
 /**
- * Terms assigned to a content entry, resolved into the active locale. Terms
- * whose translation_group lacks a row in the requested locale are omitted.
+ * Terms assigned to a content entry, resolved into the active locale and then
+ * the configured default locale.
  */
 export function getEntryTerms(
 	collection: string,
@@ -483,22 +537,7 @@ export function getEntryTerms(
 				key: `entryTerms:${collection}:${entryId}:${taxonomyName ?? "*"}:${locale ?? "*"}`,
 				load: async () => {
 					const db = await getDb();
-
-					let query = db
-						.selectFrom("content_taxonomies")
-						.innerJoin(
-							"taxonomies",
-							"taxonomies.translation_group",
-							"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);
-					if (locale !== undefined) query = query.where("taxonomies.locale", "=", locale);
-
-					const rows = await query.execute();
+					const rows = await selectEntryTermRows(db, collection, [entryId], taxonomyName, locale);
 					return rows.map<TaxonomyTerm>((row) => ({
 						id: row.id,
 						name: row.name,
@@ -583,27 +622,7 @@ export async function getTermsForEntries(
 		for (const chunk of chunks(missedIds, SQL_BATCH_SIZE)) {
 			let rows;
 			try {
-				let query = db
-					.selectFrom("content_taxonomies")
-					.innerJoin("taxonomies", "taxonomies.translation_group", "content_taxonomies.taxonomy_id")
-					.select([
-						"content_taxonomies.entry_id",
-						"taxonomies.id",
-						"taxonomies.name",
-						"taxonomies.slug",
-						"taxonomies.label",
-						"taxonomies.parent_id",
-						"taxonomies.locale",
-						"taxonomies.translation_group",
-					])
-					.where("content_taxonomies.collection", "=", collection)
-					.where("content_taxonomies.entry_id", "in", chunk)
-					.where("taxonomies.name", "=", taxonomyName)
-					// Match the order getAllTermsForEntries (the cache primer) uses, so
-					// cache-hit and DB-miss entries in one result are ordered consistently.
-					.orderBy("taxonomies.label", "asc");
-				if (locale !== undefined) query = query.where("taxonomies.locale", "=", locale);
-				rows = await query.execute();
+				rows = await selectEntryTermRows(db, collection, chunk, taxonomyName, locale);
 			} catch (error) {
 				if (isMissingTableError(error)) return [...result.entries()];
 				throw error;
@@ -665,24 +684,7 @@ export async function getAllTermsForEntries(
 	for (const chunk of chunks(uniqueIds, SQL_BATCH_SIZE)) {
 		let rows;
 		try {
-			let query = db
-				.selectFrom("content_taxonomies")
-				.innerJoin("taxonomies", "taxonomies.translation_group", "content_taxonomies.taxonomy_id")
-				.select([
-					"content_taxonomies.entry_id",
-					"taxonomies.id",
-					"taxonomies.name",
-					"taxonomies.slug",
-					"taxonomies.label",
-					"taxonomies.parent_id",
-					"taxonomies.locale",
-					"taxonomies.translation_group",
-				])
-				.where("content_taxonomies.collection", "=", collection)
-				.where("content_taxonomies.entry_id", "in", chunk)
-				.orderBy("taxonomies.label", "asc");
-			if (locale !== undefined) query = query.where("taxonomies.locale", "=", locale);
-			rows = await query.execute();
+			rows = await selectEntryTermRows(db, collection, chunk, undefined, locale);
 		} catch (error) {
 			if (isMissingTableError(error)) {
 				for (const id of uniqueIds) {

package/src/taxonomies/term-counts.ts

@@ -30,7 +30,8 @@ interface CountRow {
 /**
  * Per-collection count branch. `taxonomy_id` stores the term's
  * translation_group, so results are keyed by group (locale-independent) and
- * each assignment is counted once no matter how many locales the term has.
+ * each assignment is counted once per content translation group. When a
+ * locale is provided, only that group's matching content row contributes.
  *
  * Scoping to the taxonomy uses `translation_group IN (...)` rather than a
  * join on `taxonomies.id` — the anchor row (id == group) can be deleted while
@@ -39,20 +40,23 @@ interface CountRow {
  *
  * CROSS JOIN with the join predicate in WHERE keeps stats-blind SQLite/D1 from
  * reordering content_taxonomies out of the outer position; it touches ec_* only
- * by primary key. Postgres treats this as an ordinary inner join and plans freely.
+ * through the translation-group index. Postgres treats this as an ordinary
+ * inner join and plans freely.
  */
 function collectionBranch(
 	db: Kysely<Database>,
 	taxonomyName: string,
 	collection: string,
+	locale?: string,
 ): ReturnType<typeof sql> {
 	return sql`
-		SELECT ct.taxonomy_id AS taxonomy_id, COUNT(*) AS count
+		SELECT ct.taxonomy_id AS taxonomy_id, COUNT(DISTINCT e.translation_group) AS count
 		FROM content_taxonomies AS ct
 		CROSS JOIN ${sql.ref(`ec_${collection}`)} AS e
-		WHERE e.id = ct.entry_id
+		WHERE e.translation_group = ct.entry_id
 			AND ct.collection = ${collection}
 			AND ct.taxonomy_id IN (SELECT translation_group FROM taxonomies WHERE name = ${taxonomyName})
+			${locale ? sql`AND e.locale = ${locale}` : sql``}
 			AND ${buildStatusCondition(db, "published", "e")}
 			AND e.deleted_at IS NULL
 		GROUP BY ct.taxonomy_id`;
@@ -62,8 +66,11 @@ async function runCounts(
 	db: Kysely<Database>,
 	taxonomyName: string,
 	collections: string[],
+	locale?: string,
 ): Promise<Map<string, number>> {
-	const branches = collections.map((collection) => collectionBranch(db, taxonomyName, collection));
+	const branches = collections.map((collection) =>
+		collectionBranch(db, taxonomyName, collection, locale),
+	);
 	const union = sql.join(branches, sql` UNION ALL `);
 	const result = await sql<CountRow>`
 		SELECT taxonomy_id, SUM(count) AS count
@@ -87,9 +94,10 @@ async function runBatch(
 	db: Kysely<Database>,
 	taxonomyName: string,
 	collections: string[],
+	locale?: string,
 ): Promise<Map<string, number>> {
 	try {
-		return await runCounts(db, taxonomyName, collections);
+		return await runCounts(db, taxonomyName, collections, locale);
 	} catch (error) {
 		if (!isMissingTableError(error)) throw error;
 	}
@@ -97,7 +105,7 @@ async function runBatch(
 	const counts = new Map<string, number>();
 	for (const collection of collections) {
 		try {
-			addCounts(counts, await runCounts(db, taxonomyName, [collection]));
+			addCounts(counts, await runCounts(db, taxonomyName, [collection], locale));
 		} catch (error) {
 			if (!isMissingTableError(error)) throw error;
 		}
@@ -108,6 +116,8 @@ async function runBatch(
 /**
  * Count publicly-visible term assignments for one taxonomy, keyed by the
  * term's translation_group (what `content_taxonomies.taxonomy_id` stores).
+ * When `locale` is provided, only entries in that locale contribute. Omitting
+ * it preserves the locale-agnostic API used by legacy callers.
  *
  * Counts are scoped to the taxonomy's declared collections — pass
  * `TaxonomyDef.collections` (`_emdash_taxonomy_defs.collections`). Collections
@@ -130,6 +140,7 @@ export async function fetchVisibleTermCounts(
 	db: Kysely<Database>,
 	taxonomyName: string,
 	collections: string[],
+	locale?: string,
 ): Promise<Map<string, number>> {
 	const unique = [...new Set(collections)];
 	for (const collection of unique) validateIdentifier(collection, "collection slug");
@@ -137,7 +148,9 @@ export async function fetchVisibleTermCounts(
 
 	const limit = compoundSelectLimit(db);
 	const batched = limit === null ? [unique] : chunks(unique, limit);
-	const batches = await Promise.all(batched.map((batch) => runBatch(db, taxonomyName, batch)));
+	const batches = await Promise.all(
+		batched.map((batch) => runBatch(db, taxonomyName, batch, locale)),
+	);
 
 	const counts = new Map<string, number>();
 	for (const batch of batches) addCounts(counts, batch);

package/src/utils/slugify.ts

@@ -1,17 +1,5 @@
-// Regex patterns for slug normalization
-const DIACRITICS_PATTERN = /[\u0300-\u036f]/g;
-const WHITESPACE_UNDERSCORE_PATTERN = /[\s_]+/g;
-const NON_ALPHANUMERIC_HYPHEN_PATTERN = /[^a-z0-9-]/g;
-const MULTIPLE_HYPHENS_PATTERN = /-+/g;
-const LEADING_TRAILING_HYPHEN_PATTERN = /^-|-$/g;
-const TRAILING_HYPHEN_PATTERN = /-$/;
+export { slugify } from "@emdash-cms/admin/slugify";
 
-/**
- * Convert a string to a URL-friendly slug.
- *
- * Handles unicode by normalizing to NFD and stripping diacritics,
- * so "café" becomes "cafe", "naïve" becomes "naive", etc.
- */
 /**
  * Decode a URI-encoded slug parameter.
  *
@@ -22,19 +10,3 @@ const TRAILING_HYPHEN_PATTERN = /-$/;
 export function decodeSlug(raw: string | undefined): string | undefined {
 	return raw ? decodeURIComponent(raw) : undefined;
 }
-
-export function slugify(text: string, maxLength: number = 80): string {
-	return (
-		text
-			.toLowerCase()
-			.normalize("NFD")
-			.replace(DIACRITICS_PATTERN, "")
-			.replace(WHITESPACE_UNDERSCORE_PATTERN, "-")
-			.replace(NON_ALPHANUMERIC_HYPHEN_PATTERN, "")
-			.replace(MULTIPLE_HYPHENS_PATTERN, "-")
-			.replace(LEADING_TRAILING_HYPHEN_PATTERN, "")
-			.slice(0, maxLength)
-			// Clean trailing hyphen from truncation
-			.replace(TRAILING_HYPHEN_PATTERN, "")
-	);
-}

package/src/virtual-modules.d.ts

@@ -16,6 +16,7 @@ declare module "virtual:emdash/config" {
 
 	interface VirtualConfig {
 		database?: DatabaseDescriptor;
+		migrations?: import("./database/migrations/policy.js").RuntimeMigrationConfig;
 		storage?: StorageDescriptor;
 		auth?: AuthDescriptor;
 		authProviders?: AuthProviderDescriptor[];
@@ -35,6 +36,7 @@ declare module "virtual:emdash/dialect" {
 	import type { Dialect, Kysely } from "kysely";
 
 	import type { DatabaseDialectType } from "./db/adapters.js";
+	import type { ExecuteCollectionDeletionGuard } from "./db/adapters.js";
 
 	// Can be undefined if no database configured, or the actual function
 	export const createDialect: ((config: unknown) => Dialect) | undefined;
@@ -53,6 +55,13 @@ declare module "virtual:emdash/dialect" {
 	export interface RequestScopedDbOpts {
 		config: unknown;
 		isAuthenticated: boolean;
+		/**
+		 * Evaluated at commit() time: whether the request ended authenticated.
+		 * Login/signup/invite requests start unauthenticated and establish a
+		 * session mid-request; `isAuthenticated` captures only the request-start
+		 * state.
+		 */
+		endedAuthenticated?: () => boolean;
 		isWrite: boolean;
 		/** Whether core routing allows this request to use an anonymous public-read cache. */
 		canUseCachedBinding?: boolean;
@@ -82,6 +91,7 @@ declare module "virtual:emdash/dialect" {
 		close?: () => void;
 	}
 	export const createRequestScopedDb: (opts: RequestScopedDbOpts) => RequestScopedDb | null;
+	export const executeCollectionDeletionGuard: ExecuteCollectionDeletionGuard | undefined;
 }
 
 declare module "virtual:emdash/storage" {
@@ -178,6 +188,16 @@ declare module "virtual:emdash/env" {
 	export const env: Record<string, unknown> | undefined;
 }
 
+declare module "virtual:emdash/build" {
+	/**
+	 * Epoch milliseconds at which this build's virtual modules were generated.
+	 * Folded into the route cache validator so a code-only deploy — which
+	 * renames `/_astro/*` without touching content — still invalidates HTML a
+	 * browser cached from an earlier deployment.
+	 */
+	export const buildTime: number;
+}
+
 declare module "virtual:emdash/scheduler" {
 	import type { CreateSchedulerFn } from "./emdash-runtime.js";
 	/**
@@ -197,6 +217,8 @@ declare module "virtual:emdash/admin-registry" {
 	 *   - pages: Record<pageId, ComponentType>
 	 *   - widgets: Record<widgetId, ComponentType>
 	 *   - fields: Record<widgetName, ComponentType> (field widget renderers)
+	 *   - contentEditorPanels: Trusted content editor sidebar panels
+	 *   - contentListColumns: trusted-plugin content list column definitions
 	 */
 	export const pluginAdmins: Record<
 		string,
@@ -204,6 +226,8 @@ declare module "virtual:emdash/admin-registry" {
 			pages?: Record<string, unknown>;
 			widgets?: Record<string, unknown>;
 			fields?: Record<string, unknown>;
+			contentEditorPanels?: readonly unknown[];
+			contentListColumns?: readonly unknown[];
 		}
 	>;
 }

package/dist/adapters-BMyNSSZi.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"adapters-BMyNSSZi.d.mts","names":[],"sources":["../src/db/adapters.ts"],"mappings":";;AA0BA;;;;;AAKA;;;;;;;;;;;;;AAsCA;;;;;AAOA;KAlDY,mBAAA;;;;UAKK,kBAAA;EAChB,UAAA;EACA,MAAA;EACA,IAAA,EAAM,mBAAA;EA+DwB;;;;;AAqB/B;;;;;;;;;EArEC,oBAAA;EAgF8B;;;;;;;EAxE9B,uBAAA;EA8EA;;;;;;;AAeD;EApFC,kBAAA;AAAA;AAAA,UAGgB,YAAA;EAiFgB;;;EA7EhC,GAAA;AAAA;AAAA,UAGgB,YAAA;;;;EAIhB,GAAA;;;;EAIA,SAAA;AAAA;;;;;;;;;;;iBAae,MAAA,CAAO,MAAA,EAAQ,YAAA,GAAe,kBAAA;;;;;;;;;;;;;;iBAqB9B,MAAA,CAAO,MAAA,EAAQ,YAAA,GAAe,kBAAA;;;;UAW7B,cAAA;EAChB,gBAAA;EACA,IAAA;EACA,IAAA;EACA,QAAA;EACA,IAAA;EACA,QAAA;EACA,GAAA;EACA,IAAA;IAAS,GAAA;IAAc,GAAA;EAAA;AAAA;;;;;;;;;;;iBAaR,QAAA,CAAS,MAAA,EAAQ,cAAA,GAAiB,kBAAA"}