emdash 0.18.0 → 0.20.0

package/src/emdash-runtime.ts

@@ -24,7 +24,10 @@ import { isSqlite } from "./database/dialect-helpers.js";
 import { kyselyLogOption } from "./database/instrumentation.js";
 import { MIGRATION_RACE_WAIT_MS, runMigrations } from "./database/migrations/runner.js";
 import { RevisionRepository } from "./database/repositories/revision.js";
-import type { ContentItem as ContentItemInternal } from "./database/repositories/types.js";
+import type {
+	ContentItem as ContentItemInternal,
+	ContentDateField,
+} from "./database/repositories/types.js";
 import { validateIdentifier } from "./database/validate.js";
 import { normalizeMediaValue } from "./media/normalize.js";
 import type { MediaProvider, MediaProviderCapabilities } from "./media/types.js";
@@ -42,6 +45,7 @@ import type {
 import type { FieldType } from "./schema/types.js";
 import { hashString } from "./utils/hash.js";
 import { createInitLock, type InitLock, initWithLock } from "./utils/init-lock.js";
+import { createIsolateCache, isolateCachedAsync } from "./utils/isolate-cache.js";
 import { COMMIT, VERSION } from "./version.js";
 
 const LEADING_SLASH_PATTERN = /^\//;
@@ -115,6 +119,7 @@ import { validateEncryptionKeyAtStartup } from "./config/secrets.js";
 import { OptionsRepository } from "./database/repositories/options.js";
 import {
 	handleContentList,
+	handleContentAuthors,
 	handleContentGet,
 	handleContentGetIncludingTrashed,
 	handleContentCreate,
@@ -158,13 +163,12 @@ import {
 import { normalizeManifestRoute } from "./plugins/manifest-schema.js";
 import { extractRequestMeta, sanitizeHeadersForSandbox } from "./plugins/request-meta.js";
 import { PluginRouteRegistry, type RouteMeta } from "./plugins/routes.js";
-import { NodeCronScheduler } from "./plugins/scheduler/node.js";
-import { PiggybackScheduler } from "./plugins/scheduler/piggyback.js";
 import type { CronScheduler } from "./plugins/scheduler/types.js";
 import { PluginStateRepository } from "./plugins/state.js";
 import { normalizeRegistryConfig } from "./registry/config.js";
 import { requestCached } from "./request-cache.js";
 import { getRequestContext } from "./request-context.js";
+import { publishDueContent, type PublishedRef } from "./scheduled-publish.js";
 import { FTSManager } from "./search/fts-manager.js";
 import { invalidateSiteSettingsCache } from "./settings/index.js";
 
@@ -237,6 +241,13 @@ export interface MediaProviderContext {
 	storage: Storage | null;
 }
 
+/**
+ * Builds the timer-based scheduler that drives cron ticks and maintenance.
+ * Injected via `virtual:emdash/scheduler` so the platform — not core — decides
+ * whether a long-lived heartbeat exists.
+ */
+export type CreateSchedulerFn = (executor: CronExecutor) => CronScheduler;
+
 /**
  * Dependencies injected from virtual modules (middleware reads these)
  */
@@ -250,6 +261,16 @@ export interface RuntimeDependencies {
 	sandboxEnabled: boolean;
 	/** sandbox: false escape hatch - load sandboxed plugins in-process */
 	sandboxBypassed?: boolean;
+	/**
+	 * Factory for the timer-based cron/maintenance heartbeat. Supplied by the
+	 * generated `virtual:emdash/scheduler` module: a `NodeCronScheduler` factory
+	 * on long-lived runtimes (Node/Bun), or `null` on serverless adapters where
+	 * an external driver (e.g. the Cloudflare Worker's `scheduled()` Cron
+	 * Trigger) calls `runScheduledTasks()` instead. When absent or null, the
+	 * runtime starts no scheduler. Keeping the platform decision in the
+	 * integration means core has no adapter-specific runtime checks.
+	 */
+	createScheduler?: CreateSchedulerFn | null;
 	/** Media provider entries from virtual module */
 	mediaProviderEntries?: MediaProviderEntry[];
 	sandboxedPluginEntries: SandboxedPluginEntry[];
@@ -397,12 +418,12 @@ export class EmDashRuntime {
 	private pluginStates: Map<string, string>;
 
 	/**
-	 * Set to true after FTS indexes have been verified for this worker
-	 * lifetime so we don't re-scan on every admin request. See
-	 * ensureSearchHealthy().
+	 * Isolate-lifetime guard so FTS indexes are verified at most once per
+	 * worker rather than on every admin request. See ensureSearchHealthy().
+	 * Uses the poison-immune isolate cache (never a shared awaitable promise)
+	 * so a cancelled first caller can't wedge later ones.
 	 */
-	private _searchHealthChecked = false;
-	private _searchHealthPromise: Promise<void> | null = null;
+	private readonly _searchHealthCache = createIsolateCache<void>();
 
 	/** Current hook pipeline. Use the `hooks` getter for external access. */
 	get hooks(): HookPipeline {
@@ -479,14 +500,65 @@ export class EmDashRuntime {
 	}
 
 	/**
-	 * Tick the cron system from request context (piggyback mode).
-	 * Call this from middleware on each request to ensure cron tasks
-	 * execute even when no dedicated scheduler is available.
+	 * Publish any content whose scheduled time has passed.
+	 * Returns the items promoted so callers can invalidate their cache tags.
+	 */
+	async publishScheduled(): Promise<PublishedRef[]> {
+		return publishDueContent(this.db, {
+			publish: (collection, id, options) => this.handleContentPublish(collection, id, options),
+		});
+	}
+
+	/**
+	 * Run the full scheduled-maintenance batch: cron tasks, scheduled
+	 * publishing, and system cleanup. For request-less drivers — the
+	 * Cloudflare `scheduled()` handler invokes this from a Cron Trigger.
+	 * (On Node the timer-based scheduler drives the same work itself.)
+	 *
+	 * Each step is independent and non-fatal. Returns the content promoted
+	 * by the publishing sweep so the caller can purge edge-cache tags.
+	 *
+	 * `onPublished` (optional) is awaited after each collection's batch so a
+	 * request-less driver can invalidate edge-cache tags incrementally rather
+	 * than only after the whole sweep — bounding stale-cache exposure if the
+	 * runtime is killed mid-sweep.
 	 */
-	tickCron(): void {
-		if (this.cronScheduler instanceof PiggybackScheduler) {
-			this.cronScheduler.onRequest();
+	async runScheduledTasks(
+		options: {
+			onPublished?: (refs: PublishedRef[]) => Promise<void>;
+		} = {},
+	): Promise<{ published: PublishedRef[] }> {
+		if (this.cronExecutor) {
+			try {
+				await this.cronExecutor.tick();
+			} catch (error) {
+				console.error("[cron] Tick failed:", error);
+			}
+			try {
+				await this.cronExecutor.recoverStaleLocks();
+			} catch (error) {
+				console.error("[cron] Stale lock recovery failed:", error);
+			}
+		}
+
+		let published: PublishedRef[] = [];
+		try {
+			// Route through the runtime wrapper so content:afterPublish hooks fire.
+			published = await publishDueContent(this.db, {
+				publish: (collection, id, opts) => this.handleContentPublish(collection, id, opts),
+				onPublished: options.onPublished,
+			});
+		} catch (error) {
+			console.error("[scheduled-publish] Sweep failed:", error);
 		}
+
+		try {
+			await runSystemCleanup(this.db, this.storage ?? undefined);
+		} catch (error) {
+			console.error("[cleanup] System cleanup failed:", error);
+		}
+
+		return { published };
 	}
 
 	/**
@@ -1173,6 +1245,11 @@ export class EmDashRuntime {
 
 		let cronExecutor: CronExecutor | null = null;
 		let cronScheduler: CronScheduler | null = null;
+		// Populated with the constructed runtime just before this method returns,
+		// so the timer scheduler's cleanup can route scheduled publishing through
+		// the runtime wrapper (firing content:afterPublish hooks). The first tick
+		// is ≥1s out, well after the synchronous assignment below.
+		const runtimeRef: { current: EmDashRuntime | null } = { current: null };
 
 		await phase("rt.cron", "Cron init (recovery deferred post-response)", async () => {
 			try {
@@ -1198,46 +1275,57 @@ export class EmDashRuntime {
 					}
 				});
 
-				// Detect platform and create appropriate scheduler.
-				// On Cloudflare Workers, setTimeout is available but unreliable for
-				// long durations — use PiggybackScheduler as default.
-				// In Node/Bun, use NodeCronScheduler with real timers.
-				const isWorkersRuntime =
-					typeof globalThis.navigator !== "undefined" &&
-					globalThis.navigator.userAgent === "Cloudflare-Workers";
-
-				if (isWorkersRuntime) {
-					cronScheduler = new PiggybackScheduler(cronExecutor);
-				} else {
-					cronScheduler = new NodeCronScheduler(cronExecutor);
-				}
-
-				// Register system cleanup to run alongside each scheduler tick.
-				// Pass storage so cleanupPendingUploads can delete orphaned files.
-				cronScheduler.setSystemCleanup(async () => {
-					try {
-						await runSystemCleanup(db, storage ?? undefined);
-					} catch (error) {
-						// Non-fatal -- individual cleanup failures are already logged
-						// by runSystemCleanup. This catches unexpected errors.
-						console.error("[cleanup] System cleanup failed:", error);
-					}
-				});
+				// The platform decides whether a long-lived timer heartbeat exists.
+				// `createScheduler` is injected by the generated virtual:emdash/scheduler
+				// module: a NodeCronScheduler factory on Node/Bun, or null on serverless
+				// adapters (e.g. Cloudflare) where the Worker's `scheduled()` handler
+				// drives runScheduledTasks() instead. No adapter check lives here.
+				if (deps.createScheduler) {
+					const scheduler = deps.createScheduler(cronExecutor);
+					cronScheduler = scheduler;
+
+					// Run scheduled publishing and system cleanup alongside each tick.
+					// Pass storage so cleanupPendingUploads can delete orphaned files.
+					scheduler.setSystemCleanup(async () => {
+						try {
+							// Route through the runtime so content:afterPublish hooks fire.
+							// Falls back to the raw handler if (improbably) the tick beats
+							// the post-construction ref assignment.
+							const runtime = runtimeRef.current;
+							await publishDueContent(db, {
+								publish: runtime
+									? (collection, id, options) =>
+											runtime.handleContentPublish(collection, id, options)
+									: undefined,
+							});
+						} catch (error) {
+							console.error("[scheduled-publish] Sweep failed:", error);
+						}
+						try {
+							await runSystemCleanup(db, storage ?? undefined);
+						} catch (error) {
+							// Non-fatal -- individual cleanup failures are already logged
+							// by runSystemCleanup. This catches unexpected errors.
+							console.error("[cleanup] System cleanup failed:", error);
+						}
+					});
 
-				// Add cron reschedule callback (merges with existing factory options)
-				pipeline.setContextFactory({
-					cronReschedule: () => cronScheduler?.reschedule(),
-				});
+					// Add cron reschedule callback (merges with existing factory options)
+					pipeline.setContextFactory({
+						cronReschedule: () => cronScheduler?.reschedule(),
+					});
 
-				// Start the scheduler
-				await cronScheduler.start();
+					// start() is void on the timer scheduler but the interface
+					// allows a promise (alarm-backed schedulers); we don't block on it.
+					void scheduler.start();
+				}
 			} catch (error) {
 				console.warn("[cron] Failed to initialize cron system:", error);
 				// Non-fatal — CMS works without cron
 			}
 		});
 
-		return new EmDashRuntime({
+		const runtime = new EmDashRuntime({
 			db,
 			storage,
 			// Include bypassed sandboxed plugins in configuredPlugins so route
@@ -1260,6 +1348,10 @@ export class EmDashRuntime {
 			runtimeDeps: deps,
 			pipelineRef,
 		});
+		// Hand the constructed instance to the scheduler-cleanup closure so the
+		// timer-driven sweep can fire publish hooks (see runtimeRef above).
+		runtimeRef.current = runtime;
+		return runtime;
 	}
 
 	/**
@@ -2137,27 +2229,32 @@ export class EmDashRuntime {
 	 * defend against FTS not existing yet (pre-setup).
 	 */
 	async ensureSearchHealthy(): Promise<void> {
-		if (this._searchHealthChecked) return;
-		if (this._searchHealthPromise) return this._searchHealthPromise;
-		if (!isSqlite(this._db)) {
-			this._searchHealthChecked = true;
-			return;
+		// Non-SQLite has no FTS to verify; the check is a cheap synchronous
+		// branch, no need to cache it.
+		if (!isSqlite(this._db)) return;
+		try {
+			await isolateCachedAsync(
+				this._searchHealthCache,
+				async () => {
+					try {
+						const ftsManager = new FTSManager(this._db);
+						const repaired = await ftsManager.verifyAndRepairAll();
+						if (repaired > 0) {
+							console.log(`Repaired ${repaired} corrupted FTS index(es)`);
+						}
+					} catch {
+						// FTS tables may not exist yet (pre-setup). Non-fatal — cache
+						// the "checked" state regardless so we don't re-scan.
+					}
+				},
+				{ anchor: (promise) => after(() => promise), ownerTimeoutMs: 30_000 },
+			);
+		} catch {
+			// This check is best-effort and must never fail the calling request.
+			// The inner body already swallows verify errors; this guards the
+			// outer failure modes (owner timeout, waiter give-up) so a slow FTS
+			// scan degrades to "unverified", not a 500 on admin/search routes.
 		}
-		this._searchHealthPromise = (async () => {
-			try {
-				const ftsManager = new FTSManager(this._db);
-				const repaired = await ftsManager.verifyAndRepairAll();
-				if (repaired > 0) {
-					console.log(`Repaired ${repaired} corrupted FTS index(es)`);
-				}
-			} catch {
-				// FTS tables may not exist yet (pre-setup). Non-fatal.
-			} finally {
-				this._searchHealthChecked = true;
-				this._searchHealthPromise = null;
-			}
-		})();
-		return this._searchHealthPromise;
 	}
 
 	// =========================================================================
@@ -2174,11 +2271,19 @@ export class EmDashRuntime {
 			order?: "asc" | "desc";
 			locale?: string;
 			q?: string;
+			authorId?: string;
+			dateField?: ContentDateField;
+			dateFrom?: string;
+			dateTo?: string;
 		},
 	) {
 		return handleContentList(this.db, collection, params);
 	}
 
+	async handleContentAuthors(collection: string) {
+		return handleContentAuthors(this.db, collection);
+	}
+
 	async handleContentGet(collection: string, id: string, locale?: string) {
 		const result = await handleContentGet(this.db, collection, id, locale);
 		return this.hydrateDraftData(result);
@@ -2553,7 +2658,7 @@ export class EmDashRuntime {
 	async handleContentPublish(
 		collection: string,
 		id: string,
-		options: { publishedAt?: string } = {},
+		options: { publishedAt?: string; requireScheduledDue?: boolean } = {},
 	) {
 		const result = await handleContentPublish(this.db, collection, id, options);
 

package/src/index.ts

@@ -46,6 +46,7 @@ export type {
 // API handlers
 export {
 	handleContentList,
+	handleContentAuthors,
 	handleContentGet,
 	handleContentGetIncludingTrashed,
 	handleContentCreate,
@@ -201,6 +202,8 @@ export {
 	PluginManager,
 	createPluginManager,
 	PluginRouteError,
+	// Scheduler (Node timer heartbeat — used by virtual:emdash/scheduler)
+	NodeCronScheduler,
 	// Sandbox
 	NoopSandboxRunner,
 	SandboxNotAvailableError,
@@ -253,6 +256,10 @@ export type {
 	CollectionCommentSettings,
 	StoredComment,
 
+	// Scheduler types
+	CronScheduler,
+	SystemCleanupFn,
+
 	// Sandbox runtime types
 	SandboxRunner,
 	SandboxedPluginInstance,
@@ -406,7 +413,7 @@ export type {
 } from "./menus/types.js";
 
 // Bylines
-export { getByline, getBylineBySlug } from "./bylines/index.js";
+export { getByline, getBylineBySlug, getEntriesByByline } from "./bylines/index.js";
 export type { BylineSummary, ContentBylineCredit } from "./database/repositories/types.js";
 
 // Taxonomies

package/src/loader.ts

@@ -540,12 +540,16 @@ 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.
 	 * Other keys are treated as column filters on the content table.
 	 *
 	 * @example { category: 'news' } - taxonomy term
+	 * @example { byline: '01HXYZ...' } - entries credited to a byline (any position)
 	 * @example { series: 'main' } - exact match on a content field
 	 * @example { published_at: { gte: '2024-01-01', lt: '2025-01-01' } } - date range
 	 */
@@ -673,13 +677,21 @@ export function emdashLoader(): LiveLoader<EntryData, EntryFilter, CollectionFil
 
 				// Build cursor condition if cursor is provided
 				const cursorCondition = cursor ? buildCursorCondition(cursor, orderBy) : null;
-				const cursorConditionPrefixed = cursor
-					? buildCursorCondition(cursor, orderBy, tableName)
-					: null;
 
-				// Separate taxonomy filters from field filters
+				// Separate taxonomy / byline filters from field filters
 				let result: { rows: Record<string, unknown>[] };
-				let taxonomyFilter: { name: string; slugs: string[] } | null = null;
+				// Taxonomy filters AND together: each entry constrains the base
+				// row to match at least one of its slugs *within that taxonomy*.
+				// Term slugs are unique only within a taxonomy, so every filter
+				// keeps its own `name` and emits its own `EXISTS` clause rather
+				// than pooling slugs into one `IN`.
+				const taxonomyFilters: { name: string; slugs: string[] }[] = [];
+				// A byline filter matches entries credited to any of the given
+				// byline translation groups via the `_emdash_content_bylines`
+				// junction table. `null` means no byline filter; an empty
+				// `groups` array means the filter was requested but matches
+				// nothing (short-circuited to an empty result below).
+				let bylineFilter: { groups: string[] } | null = null;
 				const fieldFilters: Record<string, WhereValue> = {};
 
 				if (where && Object.keys(where).length > 0) {
@@ -687,56 +699,51 @@ export function emdashLoader(): LiveLoader<EntryData, EntryFilter, CollectionFil
 
 					for (const [key, value] of Object.entries(where)) {
 						if (value == null) continue;
-						if (taxNames.has(key)) {
+						if (key === "byline") {
 							if (isWhereRange(value)) {
 								console.warn(
-									`[emdash] where filter: range operators are not supported on taxonomy "${key}", ignored`,
+									`[emdash] where filter: range operators are not supported on "byline", ignored`,
 								);
 								continue;
 							}
-							if (taxonomyFilter) {
+							const groups = Array.isArray(value) ? value : [value];
+							bylineFilter = { groups };
+						} else if (taxNames.has(key)) {
+							if (isWhereRange(value)) {
 								console.warn(
-									`[emdash] where filter: only one taxonomy is supported per query, "${key}" ignored`,
+									`[emdash] where filter: range operators are not supported on taxonomy "${key}", ignored`,
 								);
 								continue;
 							}
 							const slugs = Array.isArray(value) ? value : [value];
-							taxonomyFilter = { name: key, slugs };
+							taxonomyFilters.push({ name: key, slugs });
 						} else {
 							fieldFilters[key] = value;
 						}
 					}
 				}
 
-				if (taxonomyFilter) {
-					const orderByClause = buildOrderByClause(orderBy, tableName);
-					const statusCondition = buildStatusCondition(db, status, tableName);
-					const localeCondition = locale
-						? sql`AND ${sql.ref(tableName)}.locale = ${locale}`
-						: sql``;
-					const cursorCond = cursorConditionPrefixed ? sql`AND ${cursorConditionPrefixed}` : sql``;
-					const fieldConds = buildFieldConditions(fieldFilters, tableName);
-					const fieldCondsSQL =
-						fieldConds.length > 0 ? sql`${sql.join(fieldConds, sql` AND `)}` : null;
+				// A byline or taxonomy filter with no values matches nothing —
+				// short-circuit before building SQL (an empty `IN ()` is invalid
+				// SQL on both dialects).
+				if (
+					(bylineFilter && bylineFilter.groups.length === 0) ||
+					taxonomyFilters.some((f) => f.slugs.length === 0)
+				) {
+					return { entries: [], cacheHint: { tags: [type] } };
+				}
 
-					result = await sql<Record<string, unknown>>`
-						SELECT DISTINCT ${sql.ref(tableName)}.* FROM ${sql.ref(tableName)}
-						INNER JOIN content_taxonomies ct
-							ON ct.collection = ${type}
-							AND ct.entry_id = ${sql.ref(tableName)}.id
-						INNER JOIN taxonomies t
-							ON t.id = ct.taxonomy_id
-						WHERE ${sql.ref(tableName)}.deleted_at IS NULL
-							AND ${statusCondition}
-							${localeCondition}
-							${cursorCond}
-							AND t.name = ${taxonomyFilter.name}
-							AND t.slug IN (${sql.join(taxonomyFilter.slugs.map((s) => sql`${s}`))})
-							${fieldCondsSQL ? sql`AND ${fieldCondsSQL}` : sql``}
-						${orderByClause}
-						${fetchLimit ? sql`LIMIT ${fetchLimit}` : sql``}
-					`.execute(db);
-				} else {
+				{
+					// Taxonomy and byline filters are applied as correlated
+					// `EXISTS` semi-joins rather than `INNER JOIN ... DISTINCT`.
+					// A join fan-out would force `SELECT DISTINCT table.*`, and
+					// Postgres cannot apply DISTINCT to a row containing a `json`
+					// column (no equality operator), so the join approach throws
+					// there. EXISTS matches "credited/tagged at least once"
+					// without duplicating rows, needs no DISTINCT, and works on
+					// both SQLite and Postgres. The base query stays a single-
+					// table `SELECT *`, so all field/status/locale/cursor/order
+					// conditions reference unprefixed columns as before.
 					const orderByClause = buildOrderByClause(orderBy);
 					const statusCondition = buildStatusCondition(db, status);
 					const localeFilter = locale ? sql`AND locale = ${locale}` : sql``;
@@ -745,12 +752,47 @@ export function emdashLoader(): LiveLoader<EntryData, EntryFilter, CollectionFil
 					const fieldCondsSQL =
 						fieldConds.length > 0 ? sql`${sql.join(fieldConds, sql` AND `)}` : null;
 
+					// One `EXISTS` per taxonomy, AND'd together: an entry must be
+					// tagged with a matching term in *every* requested taxonomy.
+					// Each clause pins its own `t.name`, so slugs never pool
+					// across taxonomies (they're only unique within one).
+					const taxonomyCond =
+						taxonomyFilters.length > 0
+							? sql`${sql.join(
+									taxonomyFilters.map(
+										(f) => sql`AND EXISTS (
+							SELECT 1 FROM content_taxonomies ct
+							INNER JOIN taxonomies t ON t.id = ct.taxonomy_id
+							WHERE ct.collection = ${type}
+								AND ct.entry_id = ${sql.ref(tableName)}.id
+								AND t.name = ${f.name}
+								AND t.slug IN (${sql.join(f.slugs.map((s) => sql`${s}`))})
+						)`,
+									),
+									sql` `,
+								)}`
+							: sql``;
+
+					// `_emdash_content_bylines.byline_id` stores the byline's
+					// translation_group (migration 040), so a credit spans every
+					// locale variant of the byline and we match the group directly.
+					const bylineCond = bylineFilter
+						? sql`AND EXISTS (
+							SELECT 1 FROM _emdash_content_bylines cb
+							WHERE cb.collection_slug = ${type}
+								AND cb.content_id = ${sql.ref(tableName)}.id
+								AND cb.byline_id IN (${sql.join(bylineFilter.groups.map((g) => sql`${g}`))})
+						)`
+						: sql``;
+
 					result = await sql<Record<string, unknown>>`
 						SELECT * FROM ${sql.ref(tableName)}
 						WHERE deleted_at IS NULL
 						AND ${statusCondition}
 						${localeFilter}
 						${cursorCond}
+						${taxonomyCond}
+						${bylineCond}
 						${fieldCondsSQL ? sql`AND ${fieldCondsSQL}` : sql``}
 						${orderByClause}
 						${fetchLimit ? sql`LIMIT ${fetchLimit}` : sql``}