npm - emdash - Versions diffs - 0.28.0 → 0.29.0 - Mend

emdash 0.28.0 → 0.29.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (687) hide show

package/src/seo/hreflang.ts ADDED Viewed

@@ -0,0 +1,192 @@
+/**
+ * hreflang alternate resolution for translated content (#1690).
+ *
+ * Mirrors the sitemap route's semantics so the render path and the
+ * sitemap always agree:
+ *
+ * - Alternates are emitted per published locale variant of a
+ *   translation group, including a self-referencing entry (Google
+ *   recommends the page annotate itself).
+ * - `x-default` points at the default-locale variant, falling back to
+ *   the first routable variant when the default locale has no
+ *   translation.
+ * - Variants whose locale isn't in the configured `i18n.locales` list
+ *   are dropped: linking to a route the site can't serve is worse than
+ *   no link at all.
+ * - Variants flagged `noindex` in the SEO panel are excluded — the
+ *   sitemap doesn't list them, and pointing search engines at a page
+ *   that asks not to be indexed is a contradictory signal. When the
+ *   entry itself is noindex the result is empty: a page opting out of
+ *   indexing shouldn't announce an hreflang set at all.
+ * - When i18n is disabled (or no absolute site URL can be resolved,
+ *   which hreflang requires) the result is empty and no queries run.
+ */
+import type { Kysely } from "kysely";
+import { ContentRepository } from "../database/repositories/content.js";
+import type { Database } from "../database/types.js";
+import { getI18nConfig, isI18nEnabled } from "../i18n/config.js";
+import { interpolateUrlPattern, localizePath } from "../i18n/resolve.js";
+import { requestCached } from "../request-cache.js";
+import { getCollectionInfoWithDb } from "../schema/query.js";
+import { getSiteSettingsWithDb } from "../settings/index.js";
+const TRAILING_SLASH_RE = /\/$/;
+const ABSOLUTE_URL_RE = /^https?:\/\//i;
+/**
+ * IDs of variants flagged `noindex` in the SEO panel. Entries without
+ * an `_emdash_seo` row are indexable by default (same as the sitemap).
+ * The id list is bounded by the number of configured locales, so no
+ * chunking is needed.
+ */
+async function findNoindexIds(
+	db: Kysely<Database>,
+	collection: string,
+	ids: string[],
+): Promise<Set<string>> {
+	if (ids.length === 0) return new Set();
+	const rows = await db
+		.selectFrom("_emdash_seo")
+		.select("content_id")
+		.where("collection", "=", collection)
+		.where("content_id", "in", ids)
+		.where("seo_no_index", "=", 1)
+		.execute();
+	return new Set(rows.map((r) => r.content_id));
+}
+/** A single alternate link, ready to render as `<link rel="alternate">`. */
+export interface HreflangAlternate {
+	/** Locale code, or `"x-default"` for the default variant */
+	hreflang: string;
+	/** Absolute URL of the variant */
+	href: string;
+}
+export interface HreflangOptions {
+	/**
+	 * Absolute site origin (e.g. `https://example.com`) used to build
+	 * the alternate URLs. Falls back to the site settings URL; when
+	 * neither is available the result is empty, since hreflang
+	 * requires fully-qualified URLs.
+	 */
+	siteUrl?: string;
+}
+/**
+ * Resolve hreflang alternates for a content entry.
+ *
+ * @example
+ * ```astro
+ * ---
+ * import { getHreflangAlternates } from "emdash";
+ *
+ * const alternates = await getHreflangAlternates("posts", entry.data.id, {
+ *   siteUrl: Astro.url.origin,
+ * });
+ * ---
+ * <head>
+ *   {alternates.map((a) => <link rel="alternate" hreflang={a.hreflang} href={a.href} />)}
+ * </head>
+ * ```
+ */
+export async function getHreflangAlternates(
+	collection: string,
+	entryId: string,
+	options: HreflangOptions = {},
+): Promise<HreflangAlternate[]> {
+	if (!isI18nEnabled()) return [];
+	const key = `hreflang:${collection}:${entryId}:${options.siteUrl ?? ""}`;
+	return requestCached(key, async () => {
+		const { getDb } = await import("../loader.js");
+		const db = await getDb();
+		return getHreflangAlternatesWithDb(db, collection, entryId, options);
+	});
+}
+/**
+ * Resolve hreflang alternates with an explicit db handle.
+ *
+ * @internal Use `getHreflangAlternates()` in templates. This variant is
+ * for routes/components that already have a database handle.
+ */
+export async function getHreflangAlternatesWithDb(
+	db: Kysely<Database>,
+	collection: string,
+	entryId: string,
+	options: HreflangOptions = {},
+): Promise<HreflangAlternate[]> {
+	if (!isI18nEnabled()) return [];
+	let siteUrl = options.siteUrl;
+	if (!siteUrl) {
+		const settings = await getSiteSettingsWithDb(db);
+		siteUrl = settings.url;
+	}
+	// hreflang requires fully-qualified URLs; a relative site URL would
+	// produce invalid output (and EmDashHead's isSafeHref would drop it).
+	if (!siteUrl || !ABSOLUTE_URL_RE.test(siteUrl)) return [];
+	siteUrl = siteUrl.replace(TRAILING_SLASH_RE, "");
+	const repo = new ContentRepository(db);
+	const item = await repo.findByIdOrSlug(collection, entryId);
+	if (!item) return [];
+	// Legacy rows imported before i18n may have no translation_group;
+	// treat them as a single-variant group.
+	const group = item.translationGroup || item.id;
+	let variants = await repo.findTranslations(collection, group);
+	if (variants.length === 0) variants = [item];
+	let published = variants.filter((v) => v.status === "published");
+	if (published.length === 0) return [];
+	// Exclude noindex variants, matching the sitemap's `_emdash_seo`
+	// filter so head and sitemap agree on which variants are
+	// discoverable. When the requested entry itself is noindex, emit
+	// nothing: a page opting out of indexing shouldn't announce an
+	// hreflang set.
+	const noindexIds = await findNoindexIds(
+		db,
+		collection,
+		published.map((v) => v.id),
+	);
+	if (noindexIds.has(item.id)) return [];
+	published = published.filter((v) => !noindexIds.has(v.id));
+	const info = await getCollectionInfoWithDb(db, collection);
+	const urlPattern = info?.urlPattern ?? null;
+	const resolved: Array<{ locale: string; href: string }> = [];
+	for (const variant of published) {
+		const locale = variant.locale || "en";
+		const path = interpolateUrlPattern({
+			pattern: urlPattern,
+			collection,
+			slug: variant.slug || variant.id,
+			id: variant.id,
+		});
+		const localized = await localizePath(path, locale);
+		if (localized === null) continue;
+		resolved.push({ locale, href: `${siteUrl}${localized}` });
+	}
+	if (resolved.length === 0) return [];
+	resolved.sort((a, b) => a.locale.localeCompare(b.locale));
+	const alternates: HreflangAlternate[] = resolved.map((r) => ({
+		hreflang: r.locale,
+		href: r.href,
+	}));
+	// x-default: default-locale variant, else the first routable one.
+	// Same fallback the sitemap route uses.
+	const defaultLocale = getI18nConfig()?.defaultLocale;
+	const xDefault = resolved.find((r) => r.locale === defaultLocale) ?? resolved[0];
+	if (xDefault) {
+		alternates.push({ hreflang: "x-default", href: xDefault.href });
+	}
+	return alternates;
+}

package/src/seo/index.ts CHANGED Viewed

@@ -32,6 +32,9 @@
 import type { ContentSeo } from "../database/repositories/types.js";
 import { buildSeoImageUrl } from "./media-url.js";
+export { getHreflangAlternates, getHreflangAlternatesWithDb } from "./hreflang.js";
+export type { HreflangAlternate, HreflangOptions } from "./hreflang.js";
 const TRAILING_SLASH_RE = /\/$/;
 const ABSOLUTE_URL_RE = /^https?:\/\//i;

package/src/taxonomies/index.ts CHANGED Viewed

@@ -24,6 +24,7 @@ import { peekRequestCache, requestCached, setRequestCacheEntry } from "../reques
 import { getRequestContext } from "../request-context.js";
 import { chunks, SQL_BATCH_SIZE } from "../utils/chunks.js";
 import { isMissingTableError } from "../utils/db-errors.js";
+import { fetchVisibleTermCounts } from "./term-counts.js";
 import type { TaxonomyDef, TaxonomyTerm, TaxonomyTermRow } from "./types.js";
 export interface TaxonomyQueryOptions {
@@ -214,6 +215,18 @@ export async function getTaxonomyDef(
 	});
 }
+/**
+ * Object-cache namespaces for values that embed visible term counts: the
+ * taxonomy epoch (term/assignment writes) plus each counted collection's
+ * content epoch, so publishing, unpublishing, or trashing an entry
+ * invalidates the cached count promptly. A scheduled entry becoming due
+ * flips visibility without a write, so that staleness stays bounded by the
+ * cache entry's TTL.
+ */
+function termCountNamespaces(collections: string[]): string[] {
+	return [...Array.from(new Set(collections), contentNamespace), CacheNamespace.TAXONOMIES];
+}
 /**
  * All terms of a taxonomy in a specific locale (flat for non-hierarchical,
  * tree for hierarchical).
@@ -223,37 +236,38 @@ export async function getTaxonomyTerms(
 	options: TaxonomyQueryOptions = {},
 ): Promise<TaxonomyTerm[]> {
 	const locale = resolveLocale(options.locale);
-	return requestCached(`taxonomy-terms:${taxonomyName}:${locale ?? "*"}`, () =>
-		cachedQuery({
-			namespace: CacheNamespace.TAXONOMIES,
+	return requestCached(`taxonomy-terms:${taxonomyName}:${locale ?? "*"}`, async () => {
+		const def = await getTaxonomyDef(taxonomyName, options);
+		if (!def) return [];
+		return cachedQuery({
+			namespace: termCountNamespaces(def.collections),
 			key: `terms:${taxonomyName}:${locale ?? "*"}`,
-			load: () => loadTaxonomyTerms(taxonomyName, locale, options),
-		}),
-	);
+			load: () => loadTaxonomyTerms(def, locale),
+		});
+	});
 }
 async function loadTaxonomyTerms(
-	taxonomyName: string,
+	def: TaxonomyDef,
 	locale: string | undefined,
-	options: TaxonomyQueryOptions,
 ): Promise<TaxonomyTerm[]> {
 	const db = await getDb();
-	const def = await getTaxonomyDef(taxonomyName, options);
-	if (!def) return [];
 	let termsQuery = db
 		.selectFrom("taxonomies")
 		.selectAll()
-		.where("name", "=", taxonomyName)
+		.where("name", "=", def.name)
 		.orderBy("label", "asc");
 	if (locale !== undefined) termsQuery = termsQuery.where("locale", "=", locale);
-	const rows = await termsQuery.execute();
 	// Counts are keyed by translation_group (what the pivot stores) and are
-	// locale-independent, so the aggregate is shared across every taxonomy
-	// rendered in this request (Categories + Tags widgets, etc.).
-	const counts = await getTaxonomyTermCounts();
+	// locale-independent. Only publicly visible entries are counted (#581);
+	// the map is request-cached so a term detail rendered on the same page
+	// reuses it. Independent of the terms query, so run both concurrently.
+	const [rows, counts] = await Promise.all([
+		termsQuery.execute(),
+		getVisibleTermCounts(def.name, def.collections),
+	]);
 	const flatTerms: TaxonomyTermRow[] = rows.map((row) => ({
 		id: row.id,
@@ -282,23 +296,24 @@ async function loadTaxonomyTerms(
 }
 /**
- * Per-translation-group usage counts across all taxonomies, in one aggregate
- * scan of `content_taxonomies`. Counts are locale-independent (the pivot stores
- * translation_group), so a single request-cached entry serves every taxonomy
- * that renders during the request.
+ * 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.
  */
-function getTaxonomyTermCounts(): Promise<Map<string, number>> {
-	return requestCached("taxonomy-term-counts", async () => {
+function getVisibleTermCounts(
+	taxonomyName: string,
+	collections: 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 db = await getDb();
-		const countsResult = await db
-			.selectFrom("content_taxonomies")
-			.select(["taxonomy_id"])
-			.select((eb) => eb.fn.count<number>("entry_id").as("count"))
-			.groupBy("taxonomy_id")
-			.execute();
-		const counts = new Map<string, number>();
-		for (const row of countsResult) counts.set(row.taxonomy_id, row.count);
-		return counts;
+		return fetchVisibleTermCounts(db, taxonomyName, collections);
 	});
 }
@@ -313,13 +328,16 @@ export async function getTerm(
 	options: TaxonomyQueryOptions = {},
 ): Promise<TaxonomyTerm | null> {
 	const chain = resolveLocaleChain(options.locale);
-	// Cached under the shared taxonomies epoch (bumped on any taxonomy / term
-	// assignment write). The `count` reflects content_taxonomies rows; a stale
-	// count after a bare content delete is bounded by the entry's TTL.
+	// The def supplies the collections the visible count is scoped to. It is
+	// resolved before cachedQuery so the entry lives under each collection's
+	// content namespace — publishing or unpublishing an entry invalidates the
+	// embedded count (see termCountNamespaces).
+	const def = await getTaxonomyDef(taxonomyName, options);
+	const collections = def?.collections ?? [];
 	return cachedQuery({
-		namespace: CacheNamespace.TAXONOMIES,
+		namespace: termCountNamespaces(collections),
 		key: `term:${taxonomyName}:${slug}:${chain.join(",")}`,
-		load: () => loadTerm(taxonomyName, slug, chain),
+		load: () => loadTerm(taxonomyName, slug, chain, collections),
 	});
 }
@@ -327,6 +345,7 @@ async function loadTerm(
 	taxonomyName: string,
 	slug: string,
 	chain: string[],
+	collections: string[],
 ): Promise<TaxonomyTerm | null> {
 	const db = await getDb();
@@ -360,17 +379,15 @@ async function loadTerm(
 	const termLocale = row.locale;
 	if (termLocale) childrenQuery = childrenQuery.where("locale", "=", termLocale);
-	// The usage-count and children queries both depend only on the term row,
-	// so run them concurrently to save a round trip on remote databases.
-	const [countResult, childRows] = await Promise.all([
-		db
-			.selectFrom("content_taxonomies")
-			.select((eb) => eb.fn.count<number>("entry_id").as("count"))
-			.where("taxonomy_id", "=", row.translation_group ?? row.id)
-			.executeTakeFirst(),
+	// The visible-usage counts and children queries both depend only on the
+	// term row, so run them concurrently to save a round trip on remote
+	// 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),
 		childrenQuery.execute(),
 	]);
-	const count = countResult?.count ?? 0;
+	const count = counts.get(row.translation_group ?? row.id) ?? 0;
 	const children = childRows.map<TaxonomyTerm>((child) => ({
 		id: child.id,

package/src/taxonomies/term-counts.ts ADDED Viewed

@@ -0,0 +1,117 @@
+/**
+ * Shared visible-usage counts for taxonomy terms (issue #581).
+ *
+ * `content_taxonomies` rows are written for every entry regardless of status
+ * and are never pruned on unpublish/trash, so counting the pivot directly
+ * inflates counts with drafts and soft-deleted entries. Every user-facing
+ * count (public widget, single-term page, admin term list) must instead count
+ * only entries that are currently visible on the public site:
+ * `status = 'published'` OR (`status = 'scheduled'` AND due), AND
+ * `deleted_at IS NULL` — via `buildStatusCondition`, which computes scheduled
+ * visibility at query time rather than trusting a literal status value.
+ *
+ * The public render path is latency-sensitive on D1, so per-collection counts
+ * are combined into a single round-trip with UNION ALL — one query per
+ * taxonomy, never one per collection.
+ */
+import type { Kysely } from "kysely";
+import { sql } from "kysely";
+import { buildStatusCondition } from "../database/dialect-helpers.js";
+import type { Database } from "../database/types.js";
+import { validateIdentifier } from "../database/validate.js";
+import { isMissingTableError } from "../utils/db-errors.js";
+interface CountRow {
+	taxonomy_id: string;
+	count: number | string | bigint;
+}
+/**
+ * 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.
+ *
+ * Scoping to the taxonomy uses `translation_group IN (...)` rather than a
+ * join on `taxonomies.id` — the anchor row (id == group) can be deleted while
+ * sibling translations survive, and a plain join on `translation_group` would
+ * multiply counts by the number of locales.
+ */
+function collectionBranch(
+	db: Kysely<Database>,
+	taxonomyName: string,
+	collection: string,
+): ReturnType<typeof sql> {
+	return sql`
+		SELECT ct.taxonomy_id AS taxonomy_id, COUNT(*) AS count
+		FROM content_taxonomies AS ct
+		INNER JOIN ${sql.ref(`ec_${collection}`)} AS e ON e.id = ct.entry_id
+		WHERE ct.collection = ${collection}
+			AND ct.taxonomy_id IN (SELECT translation_group FROM taxonomies WHERE name = ${taxonomyName})
+			AND ${buildStatusCondition(db, "published", "e")}
+			AND e.deleted_at IS NULL
+		GROUP BY ct.taxonomy_id`;
+}
+async function runCounts(
+	db: Kysely<Database>,
+	taxonomyName: string,
+	collections: string[],
+): Promise<Map<string, number>> {
+	const branches = collections.map((collection) => collectionBranch(db, taxonomyName, collection));
+	const union = sql.join(branches, sql` UNION ALL `);
+	const result = await sql<CountRow>`
+		SELECT taxonomy_id, SUM(count) AS count
+		FROM (${union}) AS per_collection
+		GROUP BY taxonomy_id`.execute(db);
+	const counts = new Map<string, number>();
+	for (const row of result.rows) counts.set(row.taxonomy_id, Number(row.count));
+	return counts;
+}
+/**
+ * Count publicly-visible term assignments for one taxonomy, keyed by the
+ * term's translation_group (what `content_taxonomies.taxonomy_id` stores).
+ *
+ * Counts are scoped to the taxonomy's declared collections — pass
+ * `TaxonomyDef.collections` (`_emdash_taxonomy_defs.collections`). Collections
+ * whose `ec_*` table doesn't exist (pre-migration drift, a declared collection
+ * that was never created) are skipped, yielding a partial-but-correct count
+ * rather than a throw.
+ *
+ * One database round-trip for the whole taxonomy (UNION ALL across
+ * collections). Callers on the public render path should go through the
+ * request-cached wrapper in `taxonomies/index.ts` so a page rendering both the
+ * widget and a term detail shares one computation.
+ */
+export async function fetchVisibleTermCounts(
+	db: Kysely<Database>,
+	taxonomyName: string,
+	collections: string[],
+): Promise<Map<string, number>> {
+	const unique = [...new Set(collections)];
+	for (const collection of unique) validateIdentifier(collection, "collection slug");
+	if (unique.length === 0) return new Map();
+	try {
+		return await runCounts(db, taxonomyName, unique);
+	} catch (error) {
+		if (!isMissingTableError(error)) throw error;
+	}
+	// A declared collection has no ec_* table — retry per collection so the
+	// existing tables still contribute (still scheduled-aware + deleted_at).
+	const counts = new Map<string, number>();
+	for (const collection of unique) {
+		try {
+			for (const [group, count] of await runCounts(db, taxonomyName, [collection])) {
+				counts.set(group, (counts.get(group) ?? 0) + count);
+			}
+		} catch (error) {
+			if (!isMissingTableError(error)) throw error;
+		}
+	}
+	return counts;
+}

package/src/virtual-modules.d.ts CHANGED Viewed

@@ -20,6 +20,7 @@ declare module "virtual:emdash/config" {
 		auth?: AuthDescriptor;
 		authProviders?: AuthProviderDescriptor[];
 		i18n?: I18nConfig | null;
+		toolbar?: "server" | "client" | false;
 	}
 	const config: VirtualConfig;

package/src/visual-editing/editable.ts CHANGED Viewed

@@ -46,33 +46,36 @@ export function createEditable(
 		...(options?.hasDraft && { hasDraft: true }),
 	};
-	return new Proxy({} as EditProxy, {
-		get(_, prop) {
-			if (prop === "toJSON") return () => ({ "data-emdash-ref": JSON.stringify(base) });
-			if (typeof prop === "symbol") return undefined;
+	return new Proxy(
+		{},
+		{
+			get(_, prop) {
+				if (prop === "toJSON") return () => ({ "data-emdash-ref": JSON.stringify(base) });
+				if (typeof prop === "symbol") return undefined;
-			// data-emdash-ref access returns the entry-level string
-			if (prop === "data-emdash-ref") return JSON.stringify(base);
+				// data-emdash-ref access returns the entry-level string
+				if (prop === "data-emdash-ref") return JSON.stringify(base);
-			// Field-level: return a FieldAnnotation for the specific field
-			return {
-				"data-emdash-ref": JSON.stringify({ ...base, field: String(prop) }),
-			} satisfies FieldAnnotation;
-		},
-		ownKeys() {
-			return ["data-emdash-ref"];
-		},
-		getOwnPropertyDescriptor(_, prop) {
-			if (prop === "data-emdash-ref") {
+				// Field-level: return a FieldAnnotation for the specific field
 				return {
-					configurable: true,
-					enumerable: true,
-					value: JSON.stringify(base),
-				};
-			}
-			return undefined;
+					"data-emdash-ref": JSON.stringify({ ...base, field: String(prop) }),
+				} satisfies FieldAnnotation;
+			},
+			ownKeys() {
+				return ["data-emdash-ref"];
+			},
+			getOwnPropertyDescriptor(_, prop) {
+				if (prop === "data-emdash-ref") {
+					return {
+						configurable: true,
+						enumerable: true,
+						value: JSON.stringify(base),
+					};
+				}
+				return undefined;
+			},
 		},
-	});
+	);
 }
 /**
@@ -80,19 +83,22 @@ export function createEditable(
  * Spreading this produces no attributes.
  */
 export function createNoop(): EditProxy {
-	return new Proxy({} as EditProxy, {
-		get(_, prop) {
-			if (typeof prop === "symbol") return undefined;
-			// All property access returns undefined in noop mode
-			return undefined;
-		},
-		ownKeys() {
-			return [];
-		},
-		getOwnPropertyDescriptor() {
-			return undefined;
+	return new Proxy(
+		{},
+		{
+			get(_, prop) {
+				if (typeof prop === "symbol") return undefined;
+				// All property access returns undefined in noop mode
+				return undefined;
+			},
+			ownKeys() {
+				return [];
+			},
+			getOwnPropertyDescriptor() {
+				return undefined;
+			},
 		},
-	});
+	);
 }
 /**