emdash 0.32.0 → 0.34.0

package/src/plugins/types.ts

@@ -42,8 +42,17 @@ import type { z } from "astro/zod";
 // Core Types
 // =============================================================================
 
+import type { ContentFieldFilters } from "../content-list-query.js";
 import type { FieldType } from "../schema/types.js";
 
+export type {
+	ContentFieldFilterScalar,
+	ContentFieldFilterValue,
+	ContentFieldFilters,
+	ContentFieldInFilter,
+	ContentFieldRangeFilter,
+} from "../content-list-query.js";
+
 export {
 	CAPABILITY_RENAMES,
 	capabilitiesToDeclaredAccess,
@@ -227,6 +236,8 @@ export interface ContentListWhere {
 	status?: string;
 	/** Exact match on `locale` (e.g. `"en"`, `"fr-CA"`). */
 	locale?: string;
+	/** AND-combined filters over custom fields explicitly marked as indexed. */
+	fieldFilters?: ContentFieldFilters;
 }
 
 /**
@@ -251,6 +262,12 @@ export type ContentWriteInput = Record<string, unknown> & {
 	seo?: ContentItemSeoInput;
 };
 
+/** Options accepted by `content.create`. */
+export interface ContentCreateOptions {
+	/** Locale for the new content row. Defaults to the configured site locale, then `en`. */
+	locale?: string;
+}
+
 /**
  * Taxonomy definition returned from the taxonomy API (e.g. "category", "tag").
  */
@@ -299,7 +316,11 @@ export interface ContentAccess {
 	list(collection: string, options?: ContentListOptions): Promise<PaginatedResult<ContentItem>>;
 
 	// Write operations (requires write:content) - optional on interface
-	create?(collection: string, data: ContentWriteInput): Promise<ContentItem>;
+	create?(
+		collection: string,
+		data: ContentWriteInput,
+		options?: ContentCreateOptions,
+	): Promise<ContentItem>;
 	update?(collection: string, id: string, data: ContentWriteInput): Promise<ContentItem>;
 	delete?(collection: string, id: string): Promise<boolean>;
 }
@@ -325,7 +346,11 @@ export interface TaxonomyAccess {
  * Full content access with write operations
  */
 export interface ContentAccessWithWrite extends ContentAccess {
-	create(collection: string, data: ContentWriteInput): Promise<ContentItem>;
+	create(
+		collection: string,
+		data: ContentWriteInput,
+		options?: ContentCreateOptions,
+	): Promise<ContentItem>;
 	update(collection: string, id: string, data: ContentWriteInput): Promise<ContentItem>;
 	delete(collection: string, id: string): Promise<boolean>;
 }
@@ -1175,6 +1200,18 @@ export interface RouteContext<TInput = unknown> extends PluginContext {
 	request: Request;
 	/** Normalized request metadata (IP, user agent, geo) */
 	requestMeta: RequestMeta;
+	/**
+	 * Authenticated caller, if the route is private. The host has already
+	 * authenticated and authorized this user before dispatch, so the value
+	 * is trustworthy — unlike a user id read from the request body.
+	 *
+	 * `undefined` for public routes (which skip auth entirely) and for
+	 * token-authed requests where no user is bound to the token.
+	 *
+	 * Not gated by the `users:read` capability: this is the caller's own
+	 * identity for the current request, not a user directory lookup.
+	 */
+	user?: UserInfo;
 }
 
 /**

package/src/query.ts

@@ -27,8 +27,10 @@
 import { encodeCursor } from "./database/repositories/types.js";
 import { getFallbackChain, getI18nConfig, isI18nEnabled } from "./i18n/config.js";
 import {
+	creditsFromFoldedBylines,
 	CURSOR_RAW_VALUES,
 	FOLDED_BYLINES,
+	FOLDED_BYLINES_EXIST,
 	FOLDED_TERMS,
 	type WhereRange,
 	type WhereValue,
@@ -40,6 +42,7 @@ import {
 } from "./object-cache/index.js";
 import { requestCached } from "./request-cache.js";
 import { getRequestContext } from "./request-context.js";
+import { compileUrlPattern } from "./schema/url-pattern.js";
 import type { TaxonomyTerm } from "./taxonomies/types.js";
 import { isMissingTableError } from "./utils/db-errors.js";
 import {
@@ -310,17 +313,6 @@ function dataStr(data: Record<string, unknown>, key: string, fallback = ""): str
 	return typeof val === "string" ? val : fallback;
 }
 
-/** Safely read a date-like field from a Record */
-function dataDate(data: Record<string, unknown>, key: string): Date | undefined {
-	const val = data[key];
-	if (val instanceof Date) {
-		return Number.isNaN(val.getTime()) ? undefined : val;
-	}
-	if (typeof val !== "string" && typeof val !== "number") return undefined;
-	const date = new Date(val);
-	return Number.isNaN(date.getTime()) ? undefined : date;
-}
-
 /** Type guard for Record<string, unknown> */
 function isRecord(value: unknown): value is Record<string, unknown> {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -764,8 +756,8 @@ async function getEmDashCollectionUncached<T extends string, D = InferCollection
 	// round-trip cost on remote databases (D1 replicas, etc.).
 	await Promise.all([
 		hydrateEntryBylines(type, entriesWithEdit),
-		// Hydrate terms in the same locale the content rows were resolved to,
-		// otherwise localized entries get default-locale taxonomy terms (#1441).
+		// Use the content query locale as the preferred term locale; hydration
+		// falls back only to the configured default when a group lacks that variant.
 		hydrateEntryTerms(type, entriesWithEdit, resolvedLocale),
 	]);
 
@@ -828,23 +820,9 @@ export async function getEmDashEntry<T extends string, D = InferCollectionData<T
 		};
 	}
 
-	/** Check if an entry is publicly visible (published or scheduled past its time) */
+	/** Check if an entry has completed publication. */
 	function isVisible(entry: ContentEntry<D>): boolean {
-		const data = entryData(entry);
-		const status = dataStr(data, "status");
-		const scheduledAt = dataDate(data, "scheduledAt");
-		const isPublished = status === "published";
-		const isScheduledAndReady =
-			status === "scheduled" && scheduledAt !== undefined && scheduledAt.getTime() <= Date.now();
-		return isPublished || !!isScheduledAndReady;
-	}
-
-	/** True when an entry is scheduled to become visible at a future time. */
-	function isPendingScheduled(entry: ContentEntry<D>): boolean {
-		const data = entryData(entry);
-		if (dataStr(data, "status") !== "scheduled") return false;
-		const scheduledAt = dataDate(data, "scheduledAt");
-		return scheduledAt !== undefined && scheduledAt.getTime() > Date.now();
+		return dataStr(entryData(entry), "status") === "published";
 	}
 
 	// Build the fallback chain: [requestedLocale, fallback1, ..., defaultLocale]
@@ -858,10 +836,8 @@ export async function getEmDashEntry<T extends string, D = InferCollectionData<T
 		opts: { isPreview: boolean; fallbackLocale?: string; cacheHint: CacheHint },
 	): Promise<EntryResult<D>> {
 		if (!opts.isPreview) stripRevisionMetadata(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.
+		// No-i18n callers use the legacy wildcard cache key. The query path still
+		// resolves against the stored content-row locale when this is undefined.
 		const termLocale = isI18nEnabled()
 			? dataStr(entryData(wrapped), "locale") || undefined
 			: undefined;
@@ -954,11 +930,6 @@ export async function getEmDashEntry<T extends string, D = InferCollectionData<T
 	// hydration) is wrapped in the distributed L2 cache, keyed by the requested
 	// locale. Preview/edit requests took the `serveDrafts` branch above and
 	// never reach here; the object cache additionally bypasses them.
-	// A scheduled entry becomes visible on a future clock tick, not on a write,
-	// so an L2 snapshot taken before its time would keep it hidden past go-live
-	// (until the publish sweep bumps the epoch or the TTL lapses). Mark such a
-	// resolution time-sensitive and skip caching it.
-	let timeSensitive = false;
 
 	const resolveNormal = async (): Promise<EntryResult<D>> => {
 		for (let i = 0; i < localeChain.length; i++) {
@@ -977,9 +948,6 @@ export async function getEmDashEntry<T extends string, D = InferCollectionData<T
 					cacheHint: cacheHint ?? {},
 				});
 			}
-			if (entry && isPendingScheduled(entry)) {
-				timeSensitive = true;
-			}
 			// Entry not found or not visible in this locale — try next
 		}
 		return { entry: null, isPreview: false, cacheHint: {} };
@@ -1003,7 +971,7 @@ export async function getEmDashEntry<T extends string, D = InferCollectionData<T
 				},
 			};
 		},
-		cacheable: (snap) => snap.ok && !timeSensitive,
+		cacheable: (snap) => snap.ok,
 	});
 
 	if (!snapshot.ok) {
@@ -1049,32 +1017,33 @@ async function hydrateEntryBylines<D>(type: string, entries: ContentEntry<D>[]):
 			const data = entryData(entry);
 			const folded = Reflect.get(data, FOLDED_BYLINES);
 			const rows = Array.isArray(folded) ? folded : [];
-			const credits = rows
-				.map((raw) => {
-					const b = raw?.byline ?? {};
-					return {
-						roleLabel: raw?.roleLabel ?? null,
-						sortOrder: Number(raw?.sortOrder ?? 0),
-						source: "explicit" as const,
-						byline: { ...b, isGuest: Boolean(b.isGuest), customFields: {} },
-					};
-				})
-				.toSorted((a, b) => a.sortOrder - b.sortOrder);
+			const credits = creditsFromFoldedBylines(rows);
 			return { data, credits };
 		});
 
+		// An empty `_emdash_bylines` table makes an empty fold authoritative: no
+		// credit can exist in any locale and the author fallback has no byline
+		// to resolve to, so skip the query path and the custom-fields probe
+		// entirely. A missing marker (older cached rows) means "unknown" and
+		// keeps the conservative fallback below.
+		const knownEmpty = entries.every(
+			(e) => Reflect.get(entryData(e), FOLDED_BYLINES_EXIST) === false,
+		);
+
 		// Fall back to the full query path when the fold can't be trusted to be
 		// complete: an entry with a byline reference (explicit primary, or an
 		// author for the author-fallback) but no folded credits — e.g. a credit
 		// in a different locale than the row, which the locale-correlated subquery
 		// skips, or the author-fallback path which the fold doesn't express.
-		let needsQueryPath = parsed.some(
-			(p) =>
-				p.credits.length === 0 &&
-				(dataStr(p.data, "authorId") !== "" || dataStr(p.data, "primaryBylineId") !== ""),
-		);
+		let needsQueryPath =
+			!knownEmpty &&
+			parsed.some(
+				(p) =>
+					p.credits.length === 0 &&
+					(dataStr(p.data, "authorId") !== "" || dataStr(p.data, "primaryBylineId") !== ""),
+			);
 		let hasCustomFields = false;
-		if (!needsQueryPath) {
+		if (!needsQueryPath && !knownEmpty) {
 			try {
 				const { getDb } = await import("./loader.js");
 				const db = await getDb();
@@ -1161,10 +1130,9 @@ 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.
+ * `locale` is the preferred locale the entries were resolved to. Each assigned
+ * group resolves that variant first, then the configured default. When it is
+ * omitted, the stored locale of each content row is preferred.
  *
  * Fails silently if the taxonomy tables don't exist yet (pre-migration).
  */
@@ -1331,26 +1299,27 @@ export interface ResolvePathResult<T = Record<string, unknown>> {
 	params: Record<string, string>;
 }
 
-/** Matches `{paramName}` placeholders in URL patterns */
-const URL_PARAM_PATTERN = /\{(\w+)\}/g;
-
-/** Convert a URL pattern like "/blog/{slug}" to a regex and param name list */
-function patternToRegex(pattern: string): { regex: RegExp; paramNames: string[] } {
-	const paramNames: string[] = [];
-	const regexStr = pattern.replace(URL_PARAM_PATTERN, (_match, name: string) => {
-		paramNames.push(name);
-		return "([^/]+)";
-	});
-	return { regex: new RegExp(`^${regexStr}$`), paramNames };
-}
-
 /** Cached compiled URL patterns for resolveEmDashPath */
 interface CachedPattern {
 	slug: string;
 	regex: RegExp;
 	paramNames: string[];
 }
-let cachedUrlPatterns: CachedPattern[] | null = null;
+
+interface UrlPatternCache {
+	patterns: CachedPattern[] | null;
+}
+
+const URL_PATTERN_CACHE_KEY = Symbol.for("emdash:url-pattern-cache");
+const queryGlobal = globalThis as Record<symbol, unknown>;
+const urlPatternCache: UrlPatternCache =
+	// eslint-disable-next-line typescript/no-unsafe-type-assertion -- globalThis singleton pattern (see request-context.ts)
+	(queryGlobal[URL_PATTERN_CACHE_KEY] as UrlPatternCache | undefined) ??
+	(() => {
+		const cache: UrlPatternCache = { patterns: null };
+		queryGlobal[URL_PATTERN_CACHE_KEY] = cache;
+		return cache;
+	})();
 
 /**
  * Invalidate the cached URL patterns used by resolveEmDashPath.
@@ -1361,7 +1330,7 @@ let cachedUrlPatterns: CachedPattern[] | null = null;
  * every schema-mutation path already routes through here.
  */
 export function invalidateUrlPatternCache(): void {
-	cachedUrlPatterns = null;
+	urlPatternCache.patterns = null;
 	invalidateSchemaObjectCache();
 }
 
@@ -1388,6 +1357,7 @@ export async function resolveEmDashPath<T = Record<string, unknown>>(
 	path: string,
 ): Promise<ResolvePathResult<T> | null> {
 	// Build and cache compiled patterns on first call
+	let cachedUrlPatterns = urlPatternCache.patterns;
 	if (!cachedUrlPatterns) {
 		const { getDb } = await import("./loader.js");
 		const { SchemaRegistry } = await import("./schema/registry.js");
@@ -1398,9 +1368,10 @@ export async function resolveEmDashPath<T = Record<string, unknown>>(
 		cachedUrlPatterns = [];
 		for (const collection of collections) {
 			if (!collection.urlPattern) continue;
-			const { regex, paramNames } = patternToRegex(collection.urlPattern);
+			const { regex, paramNames } = compileUrlPattern(collection.urlPattern);
 			cachedUrlPatterns.push({ slug: collection.slug, regex, paramNames });
 		}
+		urlPatternCache.patterns = cachedUrlPatterns;
 	}
 
 	for (const pattern of cachedUrlPatterns) {

package/src/redirects/cache.ts

@@ -1,19 +1,27 @@
 /**
  * Redirect rule cache.
  *
- * Module-level cache for enabled redirect rules. The middleware populates this
- * on first request; route handlers invalidate it on writes.
+ * Worker-isolate cache for enabled redirect rules. The middleware populates
+ * this on first request; route handlers invalidate it on writes. Cached rules
+ * expire so writes handled by another isolate become visible here too.
  *
  * Both exact-match and pattern rules are loaded from one query and cached
  * together: exact rules indexed by source path in a Map, pattern rules
  * pre-compiled into an array. A single warm request issues zero database
- * queries; a cold isolate issues one.
+ * queries; a cold or expired isolate issues one.
  *
  * This module deliberately has NO Astro imports so it can be safely imported
  * from handlers, seed, CLI, and tests without dragging in `astro:middleware`.
  */
 
+import { after } from "../after.js";
 import type { Redirect } from "../database/repositories/redirect.js";
+import {
+	createSingleFlightCache,
+	type SingleFlightCache,
+	invalidateSingleFlightCache,
+	singleFlightCached,
+} from "../utils/single-flight-cache.js";
 import type { CompiledPattern } from "./patterns.js";
 import { compilePattern, interpolateDestination, matchPattern } from "./patterns.js";
 
@@ -29,33 +37,54 @@ export interface CachedRedirects {
 	patterns: CachedRedirectRule[];
 }
 
-/**
- * Cached enabled redirects.
- * null = not yet populated, object = cached.
- */
-let cachedRedirects: CachedRedirects | null = null;
+interface RedirectCacheState {
+	redirects: CachedRedirects | null;
+	expiresAt: number;
+	generation: number;
+	refresh: SingleFlightCache<CachedRedirects>;
+}
+
+const REDIRECT_CACHE_TTL_MS = 30_000;
+const REDIRECT_CACHE_MAX_REFRESH_ATTEMPTS = 3;
+const REDIRECT_CACHE_KEY = Symbol.for("emdash:redirect-cache");
+const g = globalThis as Record<symbol, unknown>;
+const cacheState: RedirectCacheState =
+	// eslint-disable-next-line typescript/no-unsafe-type-assertion -- globalThis singleton pattern (see request-context.ts)
+	(g[REDIRECT_CACHE_KEY] as RedirectCacheState | undefined) ??
+	(() => {
+		const state: RedirectCacheState = {
+			redirects: null,
+			expiresAt: 0,
+			generation: 0,
+			refresh: createSingleFlightCache<CachedRedirects>(),
+		};
+		g[REDIRECT_CACHE_KEY] = state;
+		return state;
+	})();
 
 /**
  * Invalidate the cached redirects (both exact and pattern).
  * Call when redirects are created, updated, or deleted.
  */
 export function invalidateRedirectCache(): void {
-	cachedRedirects = null;
+	cacheState.generation++;
+	cacheState.redirects = null;
+	cacheState.expiresAt = 0;
+	invalidateSingleFlightCache(cacheState.refresh);
 }
 
 /**
  * Get the cached redirects, or null if the cache is cold.
  */
-export function getCachedRedirects(): CachedRedirects | null {
-	return cachedRedirects;
+function getCachedRedirects(): CachedRedirects | null {
+	if (cacheState.redirects && Date.now() >= cacheState.expiresAt) {
+		invalidateRedirectCache();
+	}
+	return cacheState.redirects;
 }
 
-/**
- * Populate the cache from a list of enabled redirects (both exact and
- * pattern). The caller is responsible for passing only enabled rows — the
- * cache stores them as-is.
- */
-export function setCachedRedirects(redirects: Redirect[]): CachedRedirects {
+/** Compile enabled database rows into the in-memory lookup structures. */
+function compileRedirects(redirects: Redirect[]): CachedRedirects {
 	const exact = new Map<string, Redirect>();
 	const patterns: CachedRedirectRule[] = [];
 	for (const r of redirects) {
@@ -65,8 +94,39 @@ export function setCachedRedirects(redirects: Redirect[]): CachedRedirects {
 			exact.set(r.source, r);
 		}
 	}
-	cachedRedirects = { exact, patterns };
-	return cachedRedirects;
+	return { exact, patterns };
+}
+
+function installCachedRedirects(redirects: CachedRedirects): CachedRedirects {
+	cacheState.redirects = redirects;
+	cacheState.expiresAt = Date.now() + REDIRECT_CACHE_TTL_MS;
+	return cacheState.redirects;
+}
+
+export async function loadCachedRedirects(
+	load: () => Promise<Redirect[]>,
+): Promise<CachedRedirects> {
+	for (let attempt = 0; attempt < REDIRECT_CACHE_MAX_REFRESH_ATTEMPTS; attempt++) {
+		const cached = getCachedRedirects();
+		if (cached) return cached;
+
+		const generation = cacheState.generation;
+		const loaded = await singleFlightCached(
+			cacheState.refresh,
+			async () => compileRedirects(await load()),
+			{ anchor: (promise) => after(() => promise), ownerTimeoutMs: 30_000 },
+		);
+
+		if (generation === cacheState.generation) {
+			return installCachedRedirects(loaded);
+		}
+
+		if (attempt === REDIRECT_CACHE_MAX_REFRESH_ATTEMPTS - 1) {
+			return loaded;
+		}
+	}
+
+	throw new Error("Redirect cache refresh exhausted without loading rules");
 }
 
 /**

package/src/request-context.ts

@@ -20,6 +20,7 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 
 import type { QueryRecorder } from "./database/instrumentation.js";
+import type { DeferredTaskTracker } from "./deferred-tasks.js";
 
 /**
  * Lightweight always-on counters surfaced in Server-Timing.
@@ -102,6 +103,8 @@ export interface EmDashRequestContext {
 	 * and `requestCached`.
 	 */
 	metrics?: RequestMetrics;
+	/** Deferred work that owns resources scoped to this request. */
+	deferredTasks?: DeferredTaskTracker;
 }
 
 const ALS_KEY = Symbol.for("emdash:request-context");

package/src/scheduled-publish.ts

@@ -40,7 +40,11 @@ export const SCHEDULED_PUBLISH_BATCH_LIMIT = 100;
 export type ScheduledPublishFn = (
 	collection: string,
 	id: string,
-	options: { publishedAt?: string; requireScheduledDue?: boolean },
+	options: {
+		publishedAt?: string;
+		requireScheduledDue?: boolean;
+		expectedScheduledAt?: string;
+	},
 ) => Promise<{ success: boolean; error?: { code?: string } }>;
 
 export interface PublishDueContentOptions {
@@ -114,6 +118,7 @@ export async function publishDueContent(
 				const result = await doPublish(collection.slug, item.id, {
 					publishedAt,
 					requireScheduledDue: true,
+					expectedScheduledAt: item.scheduledAt ?? undefined,
 				});
 				if (result.success) {
 					batch.push({ collection: collection.slug, id: item.id });

package/src/scheduler-health.ts

@@ -0,0 +1,46 @@
+import type { Kysely } from "kysely";
+
+import { OptionsRepository } from "./database/repositories/options.js";
+import type { Database } from "./database/types.js";
+
+export const SCHEDULER_HEARTBEAT_OPTION = "system:scheduler:last_completed_at";
+export const SCHEDULER_STALE_AFTER_MS = 5 * 60 * 1000;
+
+export interface SchedulerHealth {
+	status: "healthy" | "stale" | "unknown";
+	lastCompletedAt: string | null;
+}
+
+export async function recordSchedulerHeartbeat(
+	db: Kysely<Database>,
+	completedAt = new Date(),
+): Promise<void> {
+	await new OptionsRepository(db).set(SCHEDULER_HEARTBEAT_OPTION, completedAt.toISOString());
+}
+
+export async function recordSchedulerHeartbeatSafely(
+	db: Kysely<Database>,
+	completedAt = new Date(),
+): Promise<void> {
+	try {
+		await recordSchedulerHeartbeat(db, completedAt);
+	} catch (error) {
+		console.error("[scheduler] Failed to record heartbeat:", error);
+	}
+}
+
+export async function getSchedulerHealth(
+	db: Kysely<Database>,
+	now = new Date(),
+): Promise<SchedulerHealth> {
+	const lastCompletedAt = await new OptionsRepository(db).get<string>(SCHEDULER_HEARTBEAT_OPTION);
+	const lastCompletedAtMs = lastCompletedAt ? Date.parse(lastCompletedAt) : Number.NaN;
+	if (!lastCompletedAt || Number.isNaN(lastCompletedAtMs)) {
+		return { status: "unknown", lastCompletedAt: null };
+	}
+
+	return {
+		status: now.getTime() - lastCompletedAtMs > SCHEDULER_STALE_AFTER_MS ? "stale" : "healthy",
+		lastCompletedAt,
+	};
+}