emdash 0.17.2 → 0.19.0

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/schema/zod-generator.ts

@@ -288,6 +288,9 @@ export function generateTypeScript(collection: CollectionWithFields): string {
 	lines.push(`  publishedAt: Date | null;`);
 	// Bylines are eagerly loaded by getEmDashCollection/getEmDashEntry
 	lines.push(`  bylines?: ContentBylineCredit[];`);
+	// Taxonomy terms are eagerly loaded by getEmDashCollection/getEmDashEntry,
+	// keyed by taxonomy name (e.g. data.terms?.tag)
+	lines.push(`  terms?: Record<string, TaxonomyTerm[]>;`);
 	lines.push(`}`);
 
 	return lines.join("\n");
@@ -312,8 +315,9 @@ export function generateTypesFile(collections: CollectionWithFields[]): string {
 		c.fields.some((f) => f.type === "portableText"),
 	);
 
-	// Build imports - ContentBylineCredit is always needed for bylines
-	const imports = ["ContentBylineCredit"];
+	// Build imports - ContentBylineCredit and TaxonomyTerm are always needed
+	// for the hydrated bylines/terms fields
+	const imports = ["ContentBylineCredit", "TaxonomyTerm"];
 	if (needsPortableText) {
 		imports.push("PortableTextBlock");
 	}

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,
@@ -189,13 +190,6 @@ export async function getTerm(
 
 	if (!row) return null;
 
-	const countResult = await db
-		.selectFrom("content_taxonomies")
-		.select((eb) => eb.fn.count<number>("entry_id").as("count"))
-		.where("taxonomy_id", "=", row.translation_group ?? row.id)
-		.executeTakeFirst();
-	const count = countResult?.count ?? 0;
-
 	let childrenQuery = db
 		.selectFrom("taxonomies")
 		.selectAll()
@@ -203,7 +197,18 @@ export async function getTerm(
 		.orderBy("label", "asc");
 	const termLocale = row.locale;
 	if (termLocale) childrenQuery = childrenQuery.where("locale", "=", termLocale);
-	const childRows = await childrenQuery.execute();
+
+	// 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(),
+		childrenQuery.execute(),
+	]);
+	const count = countResult?.count ?? 0;
 
 	const children = childRows.map<TaxonomyTerm>((child) => ({
 		id: child.id,

package/src/utils/init-lock.ts

@@ -0,0 +1,143 @@
+/**
+ * Reclaimable initialization lock for isolate-lifetime singletons.
+ *
+ * Guards "first request initializes, everyone else waits" sections
+ * (runtime creation, database init) against a workerd failure mode: if the
+ * request that owns the initialization is cancelled mid-await (client
+ * disconnect, context teardown), its continuation — including any `finally`
+ * that would release the lock — never runs. A plain boolean or shared
+ * promise then stays stuck forever and every subsequent request in the
+ * isolate hangs until the platform kills it (observed as 524s at the
+ * 100-second wall limit, with the isolate poisoned until eviction).
+ *
+ * This lock instead records *when* the owner started. Waiters poll — we
+ * deliberately never await a promise created by another request, which
+ * workerd flags — and if the owner has held the lock past `deadlineMs`,
+ * the next waiter assumes the owner is dead, reclaims the lock, and runs
+ * the initialization itself. Waiters also give up after `maxWaitMs` so a
+ * request degrades to an error response rather than hanging.
+ */
+
+export interface InitLock {
+	/** Epoch ms when the current owner claimed the lock, or null when free. */
+	ownerStartedAt: number | null;
+	/**
+	 * Monotonic claim counter identifying the current owner. Release is
+	 * gated on it: a slow owner that finishes after a waiter has reclaimed
+	 * the lock must not clear the reclaimer's claim — that would let yet
+	 * another caller claim the lock and start a third concurrent init.
+	 */
+	generation: number;
+}
+
+export function createInitLock(): InitLock {
+	return { ownerStartedAt: null, generation: 0 };
+}
+
+export interface InitLockOptions {
+	/**
+	 * Reclaim the lock if the owner has held it longer than this. Must be
+	 * comfortably above the slowest legitimate init (cold migrations on a
+	 * contended D1, including the concurrent-migrator wait) — a too-short
+	 * deadline risks two concurrent inits, a too-long one delays recovery
+	 * of a poisoned isolate. Nested locks must compose: an outer lock's
+	 * deadline must exceed the deadline of any lock its init acquires.
+	 */
+	deadlineMs?: number;
+	/** Waiter poll interval. */
+	pollMs?: number;
+	/**
+	 * Give up waiting after this long and throw instead of hanging.
+	 * Defaults to `deadlineMs` plus headroom so a waiter always survives
+	 * long enough to reclaim a dead owner before giving up.
+	 */
+	maxWaitMs?: number;
+	/**
+	 * Called with the in-flight init promise (errors pre-swallowed) so the
+	 * caller can hand it to the host's lifetime extender (waitUntil via
+	 * `after()`). If the owning request is cancelled mid-init, the anchored
+	 * promise keeps the context alive: init completes, populates the cache,
+	 * and the `finally` below releases the lock — preventing the poisoning
+	 * instead of merely recovering from it via reclaim.
+	 */
+	anchor?: (promise: Promise<void>) => void;
+}
+
+const DEFAULT_DEADLINE_MS = 15_000;
+const DEFAULT_POLL_MS = 50;
+const MAX_WAIT_HEADROOM_MS = 15_000;
+
+function sleep(ms: number): Promise<void> {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/**
+ * Return the cached value if present, otherwise initialize it under the
+ * lock. `init` is responsible for storing the value so that `getCached`
+ * returns it on subsequent calls — waiters re-check `getCached` after the
+ * owner finishes rather than sharing the owner's promise.
+ *
+ * `init` receives an `isCurrentClaim` predicate and must gate its cache
+ * publication on it: a slow init that was reclaimed past the deadline
+ * must not overwrite the value published by the reclaimer (for the
+ * runtime singleton that would orphan the reclaimer's active cron
+ * scheduler). A losing init should also tear down any side resources it
+ * started, since its result will never be published.
+ */
+export async function initWithLock<T>(
+	lock: InitLock,
+	getCached: () => T | null | undefined,
+	init: (isCurrentClaim: () => boolean) => Promise<T>,
+	options?: InitLockOptions,
+): Promise<T> {
+	const deadlineMs = options?.deadlineMs ?? DEFAULT_DEADLINE_MS;
+	const pollMs = options?.pollMs ?? DEFAULT_POLL_MS;
+	const maxWaitMs = options?.maxWaitMs ?? deadlineMs + MAX_WAIT_HEADROOM_MS;
+	// Date.now() is deliberate and only works because every loop iteration
+	// awaits: in workerd the clock only advances across I/O, so a sync spin
+	// would never observe the deadline. Don't "optimize" away the sleep.
+	const waitStart = Date.now();
+
+	for (;;) {
+		const cached = getCached();
+		if (cached !== null && cached !== undefined) {
+			return cached;
+		}
+
+		const ownerStartedAt = lock.ownerStartedAt;
+		if (ownerStartedAt === null || Date.now() - ownerStartedAt > deadlineMs) {
+			// Free, or the owner has been gone past the deadline — claim it.
+			// Synchronous between awaits, so two waiters can't both claim.
+			lock.generation += 1;
+			const claim = lock.generation;
+			lock.ownerStartedAt = Date.now();
+			try {
+				// Promise.resolve().then(...) so a synchronous throw from
+				// init still becomes a rejection after the anchor attaches.
+				const isCurrentClaim = () => lock.generation === claim;
+				const initPromise = Promise.resolve().then(() => init(isCurrentClaim));
+				options?.anchor?.(
+					initPromise.then(
+						() => undefined,
+						() => undefined,
+					),
+				);
+				return await initPromise;
+			} finally {
+				// If this request dies mid-init unanchored this never runs;
+				// the next waiter reclaims after deadlineMs instead. Release
+				// only while still the current owner: a reclaimer may have
+				// taken the lock while this (slow) init was running, and
+				// clearing its claim would admit a third concurrent init.
+				if (lock.generation === claim) {
+					lock.ownerStartedAt = null;
+				}
+			}
+		}
+
+		if (Date.now() - waitStart > maxWaitMs) {
+			throw new Error(`initWithLock: timed out after ${maxWaitMs}ms waiting for initialization`);
+		}
+		await sleep(pollMs);
+	}
+}

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.