emdash 0.18.0 → 0.19.0

package/src/query.ts

@@ -101,13 +101,19 @@ export interface CollectionFilter {
 	 */
 	cursor?: string;
 	/**
-	 * Filter by field values, taxonomy terms, or ranges.
+	 * Filter by field values, taxonomy terms, byline credits, or ranges.
 	 *
 	 * Taxonomy names are detected automatically and filtered via JOIN.
+	 * The reserved `byline` key filters by byline credit (any credit, not
+	 * just the primary one) via the `_emdash_content_bylines` junction
+	 * table; its value is one or more byline translation groups. This
+	 * matches co-authored entries, which `primary_byline_id` alone misses.
 	 * Other keys are treated as column filters on the content table.
 	 *
 	 * @example { category: 'news' } - Filter by taxonomy term
 	 * @example { category: ['news', 'featured'] } - Filter by multiple terms (OR)
+	 * @example { byline: '01HXYZ...' } - Entries credited to a byline (any position)
+	 * @example { byline: ['01HXYZ...', '01HABC...'] } - Credited to any of these bylines (OR)
 	 * @example { series: 'main' } - Exact match on a content field
 	 * @example { published_at: { gte: '2024-01-01', lt: '2025-01-01' } } - Date range
 	 */
@@ -533,7 +539,9 @@ async function getEmDashCollectionUncached<T extends string, D = InferCollection
 	// round-trip cost on remote databases (D1 replicas, etc.).
 	await Promise.all([
 		hydrateEntryBylines(type, entriesWithEdit),
-		hydrateEntryTerms(type, entriesWithEdit),
+		// Hydrate terms in the same locale the content rows were resolved to,
+		// otherwise localized entries get default-locale taxonomy terms (#1441).
+		hydrateEntryTerms(type, entriesWithEdit, resolvedLocale),
 	]);
 
 	return { entries: entriesWithEdit, nextCursor, cacheHint: cacheHint ?? {} };
@@ -611,7 +619,17 @@ export async function getEmDashEntry<T extends string, D = InferCollectionData<T
 		wrapped: ContentEntry<D>,
 		opts: { isPreview: boolean; fallbackLocale?: string; cacheHint: CacheHint },
 	): Promise<EntryResult<D>> {
-		await Promise.all([hydrateEntryBylines(type, [wrapped]), hydrateEntryTerms(type, [wrapped])]);
+		// Hydrate terms in the entry's resolved locale (fallback-aware) so a
+		// localized entry never picks up default-locale taxonomy terms (#1441).
+		// When i18n is disabled we leave the locale unset to preserve the
+		// legacy "do not filter by locale" behaviour.
+		const termLocale = isI18nEnabled()
+			? dataStr(entryData(wrapped), "locale") || undefined
+			: undefined;
+		await Promise.all([
+			hydrateEntryBylines(type, [wrapped]),
+			hydrateEntryTerms(type, [wrapped], termLocale),
+		]);
 		return {
 			entry: wrapped,
 			isPreview: opts.isPreview,
@@ -788,9 +806,18 @@ async function hydrateEntryBylines<D>(type: string, entries: ContentEntry<D>[]):
  * results and call getEntryTerms() per entry. With hydration, the list page
  * stays at a single round-trip for term data.
  *
+ * `locale` must be the locale the entries were resolved to. It is forwarded to
+ * `getAllTermsForEntries` so terms are returned in the entry's locale rather
+ * than falling back to the request-context / default locale (#1441). Pass
+ * `undefined` to keep the legacy "do not filter by locale" behaviour.
+ *
  * Fails silently if the taxonomy tables don't exist yet (pre-migration).
  */
-async function hydrateEntryTerms<D>(type: string, entries: ContentEntry<D>[]): Promise<void> {
+async function hydrateEntryTerms<D>(
+	type: string,
+	entries: ContentEntry<D>[],
+	locale?: string,
+): Promise<void> {
 	if (entries.length === 0) return;
 
 	try {
@@ -799,7 +826,7 @@ async function hydrateEntryTerms<D>(type: string, entries: ContentEntry<D>[]): P
 		const ids = entries.map((e) => dataStr(entryData(e), "id")).filter(Boolean);
 		if (ids.length === 0) return;
 
-		const termsMap = await getAllTermsForEntries(type, ids);
+		const termsMap = await getAllTermsForEntries(type, ids, { locale });
 
 		for (const entry of entries) {
 			const data = entryData(entry);

package/src/scheduled-publish.ts

@@ -0,0 +1,153 @@
+/**
+ * Scheduled publishing sweep
+ *
+ * Promotes content whose scheduled publish time has passed. Driven by the
+ * platform scheduler alongside cron ticks and system cleanup — never by a
+ * request. On Node the cron scheduler's maintenance pass calls it; on
+ * Cloudflare the Worker's `scheduled()` handler does.
+ *
+ * Like `runSystemCleanup`, each collection sweep is independent and non-fatal:
+ * one collection failing must not stop the rest.
+ */
+
+import type { Kysely } from "kysely";
+
+import { handleContentPublish } from "./api/handlers/content.js";
+import { ContentRepository } from "./database/repositories/content.js";
+import type { Database } from "./database/types.js";
+import { SchemaRegistry } from "./schema/registry.js";
+
+/** A content item that was promoted to published by a sweep. */
+export interface PublishedRef {
+	collection: string;
+	id: string;
+}
+
+/**
+ * Default cap on items promoted per collection in a single sweep. Bounds the
+ * publish/webhook fan-out of one tick so a large backlog can't exhaust a Worker
+ * invocation's CPU/subrequest budget; the remainder drains on later ticks.
+ */
+export const SCHEDULED_PUBLISH_BATCH_LIMIT = 100;
+
+/**
+ * Publishes a single content item. Mirrors the relevant subset of
+ * `handleContentPublish`'s return shape. Production callers pass
+ * `EmDashRuntime.handleContentPublish` so `content:afterPublish` hooks fire
+ * (search indexing, webhooks, syndication); the default falls back to the raw
+ * handler (no hooks) for callers that have only a `db`.
+ */
+export type ScheduledPublishFn = (
+	collection: string,
+	id: string,
+	options: { publishedAt?: string; requireScheduledDue?: boolean },
+) => Promise<{ success: boolean; error?: { code?: string } }>;
+
+export interface PublishDueContentOptions {
+	/**
+	 * Publish callback. Production callers pass the runtime's
+	 * `handleContentPublish` so `content:afterPublish` hooks fire (search
+	 * indexing, webhooks, syndication). Defaults to the raw DB handler (no hooks).
+	 */
+	publish?: ScheduledPublishFn;
+	/**
+	 * Invoked after each collection's batch with the items promoted in that
+	 * batch. Lets request-less callers (the Cloudflare `scheduled()` handler)
+	 * purge edge-cache tags incrementally instead of only after the whole sweep,
+	 * so a runtime killed mid-sweep strands at most one batch behind stale cache
+	 * rather than everything published so far. Failures are logged, never fatal.
+	 */
+	onPublished?: (refs: PublishedRef[]) => Promise<void>;
+	/**
+	 * Maximum items promoted per collection per sweep. Defaults to
+	 * `SCHEDULED_PUBLISH_BATCH_LIMIT`. Pass `0` (or a negative) for unbounded.
+	 */
+	limit?: number;
+}
+
+/**
+ * Publish every content item whose `scheduled_at` is in the past.
+ *
+ * Iterates all collections, finds due items (`findReadyToPublish` returns both
+ * scheduled drafts and published entries with pending scheduled changes), and
+ * publishes each. `publish()` clears `scheduled_at`, so a second sweep is a
+ * no-op — safe to run on every tick.
+ *
+ * Bounded per collection by `limit` (default `SCHEDULED_PUBLISH_BATCH_LIMIT`):
+ * a large backlog drains across successive ticks rather than in one unbounded
+ * pass. After each collection's batch, `onPublished` (if given) is awaited so
+ * cache-tag invalidation happens incrementally, not just at the very end.
+ *
+ * Returns every item it promoted so request-less callers (the Cloudflare
+ * `scheduled()` handler) can also act on the full set.
+ */
+export async function publishDueContent(
+	db: Kysely<Database>,
+	options: PublishDueContentOptions = {},
+): Promise<PublishedRef[]> {
+	const { publish, onPublished, limit = SCHEDULED_PUBLISH_BATCH_LIMIT } = options;
+	const published: PublishedRef[] = [];
+
+	let collections;
+	try {
+		collections = await new SchemaRegistry(db).listCollections();
+	} catch (error) {
+		console.error("[scheduled-publish] Failed to list collections:", error);
+		return published;
+	}
+
+	const repo = new ContentRepository(db);
+	const doPublish: ScheduledPublishFn =
+		publish ?? ((collection, id, opts) => handleContentPublish(db, collection, id, opts));
+	// 0 / negative means unbounded; findReadyToPublish treats that as "no LIMIT".
+	const batchLimit = limit > 0 ? limit : undefined;
+
+	for (const collection of collections) {
+		try {
+			const due = await repo.findReadyToPublish(collection.slug, batchLimit);
+			const batch: PublishedRef[] = [];
+			for (const item of due) {
+				// First publication of a scheduled draft should record the intended
+				// scheduled time, not the (later) sweep time. Items already published
+				// with pending draft changes keep their original published_at.
+				const publishedAt = item.publishedAt == null ? (item.scheduledAt ?? undefined) : undefined;
+				const result = await doPublish(collection.slug, item.id, {
+					publishedAt,
+					requireScheduledDue: true,
+				});
+				if (result.success) {
+					batch.push({ collection: collection.slug, id: item.id });
+				} else if (result.error?.code === "NOT_DUE") {
+					// Unscheduled or rescheduled between selection and publish — the
+					// editor changed their mind; skip quietly, not a failure.
+				} else {
+					console.error(
+						`[scheduled-publish] Failed to publish ${collection.slug}/${item.id}:`,
+						result.error,
+					);
+				}
+			}
+
+			if (batch.length > 0) {
+				published.push(...batch);
+				if (onPublished) {
+					// Purge this batch's cache tags before moving to the next
+					// collection, so a mid-sweep kill can't strand already-published
+					// content behind stale cache.
+					try {
+						await onPublished(batch);
+					} catch (error) {
+						console.error(
+							`[scheduled-publish] onPublished failed after "${collection.slug}" batch:`,
+							error,
+						);
+					}
+				}
+			}
+		} catch (error) {
+			console.error(`[scheduled-publish] Sweep failed for "${collection.slug}":`, error);
+		}
+	}
+
+	return published;
+}

package/src/seed/apply.ts

@@ -115,6 +115,13 @@ export async function applySeed(
 	const seedIdMap = new Map<string, string>(); // seed id -> real entry id
 	const seedBylineIdMap = new Map<string, string>(); // seed byline id -> real byline id
 
+	// Fallback locale for rows that omit an explicit `locale`. Prefer the runtime
+	// config (runtime-driven seeds), then the seed's self-described `defaultLocale`
+	// (CLI exports run outside the runtime), and only then `en`. Without the
+	// seed-carried default, a non-`en` single-locale project would be rewritten to
+	// `en` on apply (#1421).
+	const defaultLocale = getI18nConfig()?.defaultLocale ?? seed.defaultLocale ?? "en";
+
 	// 1. Site settings
 	if (seed.settings) {
 		await setSiteSettings(seed.settings, db);
@@ -224,10 +231,9 @@ export async function applySeed(
 		// seed-local id -> resolved info, used to wire `translationOf` refs.
 		const defSeedIdMap = new Map<string, { id: string; translationGroup: string }>();
 		const termSeedIdMap = new Map<string, string>();
-		const fallbackLocale = getI18nConfig()?.defaultLocale ?? "en";
 
 		for (const taxonomy of seed.taxonomies) {
-			const defLocale = taxonomy.locale ?? fallbackLocale;
+			const defLocale = taxonomy.locale ?? defaultLocale;
 
 			// (name, locale) is the UNIQUE key after migration 036.
 			const existingDef = await db
@@ -418,8 +424,13 @@ export async function applySeed(
 		// Create content entries
 		for (const [collectionSlug, entries] of Object.entries(seed.content)) {
 			for (const entry of entries) {
+				// Resolve the entry's locale up front so a non-`en` single-locale
+				// export (which omits `locale`) is filed under the project default
+				// rather than `en` (#1421).
+				const entryLocale = entry.locale ?? defaultLocale;
+
 				// Check if entry exists (by slug + locale for locale-aware lookup)
-				const existing = await contentRepo.findBySlug(collectionSlug, entry.slug, entry.locale);
+				const existing = await contentRepo.findBySlug(collectionSlug, entry.slug, entryLocale);
 
 				if (existing) {
 					if (onConflict === "error") {
@@ -515,7 +526,7 @@ export async function applySeed(
 						slug: entry.slug,
 						status,
 						data: resolvedData,
-						locale: entry.locale,
+						locale: entryLocale,
 						translationOf,
 						publishedAt: status === "published" ? new Date().toISOString() : null,
 					});
@@ -545,10 +556,9 @@ export async function applySeed(
 		const menuSeedIdMap = new Map<string, { id: string; translationGroup: string }>();
 		// Shared across menus: translated items reference anchor items in sibling menus.
 		const itemSeedIdMap = new Map<string, { id: string; translationGroup: string }>();
-		const fallbackLocale = getI18nConfig()?.defaultLocale ?? "en";
 
 		for (const menu of seed.menus) {
-			const locale = menu.locale ?? fallbackLocale;
+			const locale = menu.locale ?? defaultLocale;
 			let lookup = db
 				.selectFrom("_emdash_menus")
 				.selectAll()

package/src/seed/types.ts

@@ -19,6 +19,15 @@ export interface SeedFile {
 	/** Seed format version */
 	version: "1";
 
+	/**
+	 * Default locale for locale-bearing rows (menus, taxonomies, content) that
+	 * omit an explicit `locale`. Lets a non-`en` single-locale project survive an
+	 * `export-seed` → `seed` round-trip: `apply` runs outside the Astro runtime
+	 * (no i18n config), so without this it would backfill the omitted locale as
+	 * `en`. See #1421.
+	 */
+	defaultLocale?: string;
+
 	/** Metadata about the seed */
 	meta?: {
 		name?: string;

package/src/seed/validate.ts

@@ -57,6 +57,21 @@ export function validateSeed(data: unknown): ValidationResult {
 		errors.push(`Unsupported seed version: ${String(seed.version)}`);
 	}
 
+	// defaultLocale backfills the locale of rows that omit one, so a blank or
+	// whitespace-padded value would silently write empty/invalid locales to the DB.
+	// Exported seeds never hit this, but it's part of the public schema now.
+	if (seed.defaultLocale !== undefined) {
+		if (
+			typeof seed.defaultLocale !== "string" ||
+			seed.defaultLocale.length === 0 ||
+			seed.defaultLocale !== seed.defaultLocale.trim()
+		) {
+			errors.push(
+				"defaultLocale: must be a non-empty string with no leading or trailing whitespace",
+			);
+		}
+	}
+
 	// Validate collections
 	if (seed.collections) {
 		if (!Array.isArray(seed.collections)) {

package/src/taxonomies/index.ts

@@ -148,6 +148,7 @@ export async function getTaxonomyTerms(
 			name: term.name,
 			slug: term.slug,
 			label: term.label,
+			description: term.data ? JSON.parse(term.data).description : undefined,
 			children: [],
 			count: counts.get(term.translation_group ?? term.id) ?? 0,
 			locale: term.locale,

package/src/virtual-modules.d.ts

@@ -132,6 +132,17 @@ declare module "virtual:emdash/wait-until" {
 	export const waitUntil: ((promise: Promise<unknown>) => void) | undefined;
 }
 
+declare module "virtual:emdash/scheduler" {
+	import type { CreateSchedulerFn } from "./emdash-runtime.js";
+	/**
+	 * Factory for the timer-based cron/maintenance heartbeat. A
+	 * `NodeCronScheduler` factory on long-lived runtimes (Node/Bun); `null`
+	 * under serverless adapters (e.g. Cloudflare) where an external Cron
+	 * Trigger drives scheduled work instead.
+	 */
+	export const createScheduler: CreateSchedulerFn | null;
+}
+
 declare module "virtual:emdash/admin-registry" {
 	/**
 	 * Plugin admin module registry.