emdash 0.18.0 → 0.19.0

package/src/astro/routes/api/content/[collection]/[id].ts

@@ -132,7 +132,7 @@ export const PUT: APIRoute = async ({ params, request, locals, cache }) => {
 	return unwrapResult(result);
 };
 
-export const DELETE: APIRoute = async ({ params, locals, cache }) => {
+export const DELETE: APIRoute = async ({ params, locals, url, cache }) => {
 	const { emdash, user } = locals;
 	const collection = params.collection!;
 	const id = params.id!;
@@ -141,8 +141,10 @@ export const DELETE: APIRoute = async ({ params, locals, cache }) => {
 		return apiError("NOT_CONFIGURED", "EmDash is not initialized", 500);
 	}
 
+	const locale = url.searchParams.get("locale") || undefined;
+
 	// Fetch item to check ownership
-	const existing = await emdash.handleContentGet(collection, id);
+	const existing = await emdash.handleContentGet(collection, id, locale);
 	if (!existing.success) {
 		return apiError(
 			existing.error?.code ?? "UNKNOWN_ERROR",

package/src/astro/routes/api/content/[collection]/authors.ts

@@ -0,0 +1,34 @@
+/**
+ * Content authors endpoint - injected by EmDash integration
+ *
+ * GET /_emdash/api/content/{collection}/authors - List the distinct authors
+ * of a collection's live content, for the admin author filter.
+ */
+
+import type { APIRoute } from "astro";
+
+import { requirePerm } from "#api/authorize.js";
+import { apiError, unwrapResult } from "#api/error.js";
+
+export const prerender = false;
+
+export const GET: APIRoute = async ({ params, locals }) => {
+	const { emdash, user } = locals;
+	const collection = params.collection!;
+
+	// Editorial capability, not plain read. This response carries author
+	// emails (PII) and reveals the authors of unpublished entries, so it must
+	// not be reachable by subscribers (content:read). content:read_drafts is
+	// the same tier the list route requires before it stops forcing
+	// status=published, so the visibility surfaces line up.
+	const denied = requirePerm(user, "content:read_drafts");
+	if (denied) return denied;
+
+	if (!emdash?.handleContentAuthors) {
+		return apiError("NOT_CONFIGURED", "EmDash is not initialized", 500);
+	}
+
+	const result = await emdash.handleContentAuthors(collection);
+
+	return unwrapResult(result);
+};

package/src/astro/types.ts

@@ -233,9 +233,16 @@ export interface EmDashHandlers {
 			orderBy?: string;
 			order?: "asc" | "desc";
 			locale?: string;
+			q?: string;
+			authorId?: string;
+			dateField?: "createdAt" | "updatedAt" | "publishedAt";
+			dateFrom?: string;
+			dateTo?: string;
 		},
 	) => Promise<HandlerResponse>;
 
+	handleContentAuthors: (collection: string) => Promise<HandlerResponse>;
+
 	handleContentGet: (
 		collection: string,
 		id: string,
@@ -313,7 +320,7 @@ export interface EmDashHandlers {
 	handleContentPublish: (
 		collection: string,
 		id: string,
-		options?: { publishedAt?: string },
+		options?: { publishedAt?: string; requireScheduledDue?: boolean },
 	) => Promise<HandlerResponse>;
 
 	handleContentUnpublish: (collection: string, id: string) => Promise<HandlerResponse>;

package/src/bylines/index.ts

@@ -320,6 +320,63 @@ export async function getBylinesForEntries(
 	return result;
 }
 
+/**
+ * Get content entries credited to a byline, in any credit position.
+ *
+ * Unlike filtering on the content table's `primary_byline_id` column (which
+ * only finds entries where the byline is the first/primary credit), this
+ * matches every explicit credit recorded in `_emdash_content_bylines`, so
+ * co-authored entries where the byline is a secondary credit are included.
+ *
+ * `byline` is matched against the byline's `translation_group` (the value
+ * stored on credits since migration 040), so a single credit spans every
+ * locale variant of the byline. Pass `byline.translationGroup ?? byline.id`
+ * from `getByline` / `getBylineBySlug`. An array matches any of the given
+ * bylines (OR).
+ *
+ * The result respects the active locale, status, ordering, and eager
+ * hydration of `getEmDashCollection`.
+ *
+ * @example
+ * ```ts
+ * import { getBylineBySlug, getEntriesByByline } from "emdash";
+ *
+ * const byline = await getBylineBySlug("jane-doe");
+ * if (byline) {
+ *   const posts = await getEntriesByByline("posts", byline.translationGroup ?? byline.id, {
+ *     orderBy: { published_at: "desc" },
+ *   });
+ * }
+ * ```
+ *
+ * @param collection - The collection slug (e.g. "posts")
+ * @param byline - A byline translation group, or an array of them (OR)
+ * @param options - Optional locale, ordering, status, and limit
+ */
+export async function getEntriesByByline(
+	collection: string,
+	byline: string | string[],
+	options: {
+		locale?: string;
+		orderBy?: Record<string, "asc" | "desc">;
+		status?: "draft" | "published" | "archived";
+		limit?: number;
+	} = {},
+): Promise<Array<{ id: string; data: Record<string, unknown> }>> {
+	const { getEmDashCollection } = await import("../query.js");
+
+	const queryOptions: Record<string, unknown> = {
+		where: { byline },
+	};
+	if (options.locale !== undefined) queryOptions.locale = options.locale;
+	if (options.orderBy !== undefined) queryOptions.orderBy = options.orderBy;
+	if (options.status !== undefined) queryOptions.status = options.status;
+	if (options.limit !== undefined) queryOptions.limit = options.limit;
+
+	const { entries } = await getEmDashCollection(collection, queryOptions);
+	return entries;
+}
+
 /** Reads `author_id` + `primary_byline_id` for one entry in a single query. */
 async function getEntryContext(
 	db: Awaited<ReturnType<typeof getDb>>,

package/src/cli/commands/export-seed.ts

@@ -20,7 +20,7 @@ import { OptionsRepository } from "../../database/repositories/options.js";
 import { TaxonomyRepository } from "../../database/repositories/taxonomy.js";
 import type { Database } from "../../database/types.js";
 import { validateIdentifier } from "../../database/validate.js";
-import { isI18nEnabled } from "../../i18n/config.js";
+import { getI18nConfig, isI18nEnabled } from "../../i18n/config.js";
 import { SchemaRegistry } from "../../schema/registry.js";
 import type { FieldType } from "../../schema/types.js";
 import type {
@@ -128,7 +128,12 @@ export async function exportSeed(db: Kysely<Database>, withContent?: string): Pr
 	// middleware, but the CLI never does, so `isI18nEnabled()` is always false
 	// under `emdash export-seed` (#1330). Detecting multiple locales in the data
 	// keeps the export locale-aware without the runtime flag.
-	const i18nEnabled = await detectI18nEnabled(db, seed.collections);
+	const { i18nEnabled, defaultLocale } = await detectLocaleInfo(db, seed.collections);
+
+	// Self-describe the default locale so a non-`en` single-locale project
+	// survives the round-trip: `emdash seed` runs outside the runtime and would
+	// otherwise backfill omitted locales as `en` (#1421).
+	if (defaultLocale) seed.defaultLocale = defaultLocale;
 
 	// 3. Export taxonomy definitions and terms
 	seed.taxonomies = await exportTaxonomies(db, i18nEnabled);
@@ -216,7 +221,7 @@ async function exportBylines(
 }
 
 /**
- * Determine whether the export should emit locale-suffixed seed ids.
+ * Determine locale-awareness and the data's default locale for the export.
  *
  * The runtime initializes the i18n config in middleware, but the CLI never does,
  * so `isI18nEnabled()` is always false under `emdash export-seed` (#1330). When
@@ -227,39 +232,50 @@ async function exportBylines(
  * genuinely single-locale project from a multi-locale one. This keeps
  * single-locale exports on bare ids and gives multi-locale exports the
  * per-locale suffix they need to avoid duplicate seed ids.
+ *
+ * `defaultLocale` self-describes the single-locale case so a non-`en` default
+ * survives the round-trip (#1421). When more than one locale is present every
+ * row already carries its own `locale`, so no fallback is needed and we leave it
+ * undefined rather than guess which locale is the "default" without the runtime
+ * config.
  */
-async function detectI18nEnabled(
+async function detectLocaleInfo(
 	db: Kysely<Database>,
 	collections: SeedCollection[],
-): Promise<boolean> {
-	if (isI18nEnabled()) return true;
+): Promise<{ i18nEnabled: boolean; defaultLocale: string | undefined }> {
+	const config = getI18nConfig();
+	if (isI18nEnabled() && config) {
+		return { i18nEnabled: true, defaultLocale: config.defaultLocale };
+	}
 
 	const locales = new Set<string>();
-	const collectDistinctLocales = async (tableRef: ReturnType<typeof sql.ref>): Promise<boolean> => {
+	const collectDistinctLocales = async (tableRef: ReturnType<typeof sql.ref>): Promise<void> => {
 		const result = await sql<{ locale: string | null }>`
 			SELECT DISTINCT locale FROM ${tableRef}
 		`.execute(db);
 		for (const row of result.rows) {
 			if (row.locale) locales.add(row.locale);
 		}
-		return locales.size > 1;
 	};
 
-	if (await collectDistinctLocales(sql.ref("_emdash_taxonomy_defs"))) return true;
-	if (await collectDistinctLocales(sql.ref("_emdash_menus"))) return true;
+	await collectDistinctLocales(sql.ref("_emdash_taxonomy_defs"));
+	await collectDistinctLocales(sql.ref("_emdash_menus"));
 
 	for (const collection of collections) {
 		validateIdentifier(collection.slug, "collection slug");
 		// On D1, deleteCollection is non-atomic, so a collection row can outlive
 		// its ec_* table. Skip missing tables rather than crashing the export.
 		try {
-			if (await collectDistinctLocales(sql.ref(`ec_${collection.slug}`))) return true;
+			await collectDistinctLocales(sql.ref(`ec_${collection.slug}`));
 		} catch (error) {
 			if (!isMissingTableError(error)) throw error;
 		}
 	}
 
-	return false;
+	return {
+		i18nEnabled: locales.size > 1,
+		defaultLocale: locales.size === 1 ? [...locales][0] : undefined,
+	};
 }
 
 /**

package/src/components/EmDashImage.astro

@@ -18,11 +18,16 @@
  */
 import type { MediaValue } from "../fields/types.js";
 import type { HTMLAttributes } from "astro/types";
+import { getImage } from "astro:assets";
 import type { ImageEmbed } from "../media/types.js";
 import { getMediaProvider } from "../media/provider-loader.js";
 import { buildRenderMediaUrl } from "../media/url.js";
-// Standard responsive breakpoints
-const BREAKPOINTS = [640, 750, 828, 960, 1080, 1280, 1600, 1920];
+import {
+	buildResponsiveImage,
+	toAbsoluteMediaUrl,
+	RESPONSIVE_BREAKPOINTS,
+} from "../media/responsive.js";
+import { getPublicOrigin } from "../api/public-url.js";
 
 interface Props extends Omit<
 	HTMLAttributes<"img">,
@@ -72,7 +77,7 @@ function generateSrcset(
 	maxWidth: number,
 	aspectRatio?: number
 ): string {
-	return BREAKPOINTS.filter((w) => w <= maxWidth * 2) // Include up to 2x for retina
+	return RESPONSIVE_BREAKPOINTS.filter((w) => w <= maxWidth * 2) // Include up to 2x for retina
 		.map((w) => {
 			const h = aspectRatio ? Math.round(w / aspectRatio) : undefined;
 			return `${getSrc({ width: w, height: h })} ${w}w`;
@@ -98,8 +103,21 @@ if (img) {
 	const providerId = img.provider ?? "local";
 
 	if (providerId === "local" || img.src) {
-		// Local provider or direct src URL
+		// Local provider or direct src URL. Route through Astro's image service
+		// (`astro:assets`) to generate a responsive srcset; on Cloudflare this is
+		// the Images binding, on Node it is sharp. Falls back to a plain <img>
+		// when the service is unavailable or the source can't be optimized.
 		src = img.src || buildLocalImageUrl(img);
+		const optimized = await buildResponsiveImage(getImage, {
+			src: toAbsoluteMediaUrl(src, getPublicOrigin(Astro.url, Astro.locals.emdash?.config)),
+			width: finalWidth,
+			height: finalHeight,
+		});
+		if (optimized) {
+			src = optimized.src;
+			srcset = optimized.srcset;
+			sizes = optimized.sizes;
+		}
 	} else {
 		// External provider
 		try {

package/src/components/Image.astro

@@ -5,11 +5,16 @@
  * Renders image blocks from WordPress imports and EmDash media.
  * Uses the provider's getSrc function for responsive srcset generation.
  */
+import { getImage } from "astro:assets";
 import type { ImageEmbed } from "../media/types.js";
 import { getMediaProvider } from "../media/provider-loader.js";
 import { buildRenderMediaUrl } from "../media/url.js";
-// Standard responsive breakpoints
-const BREAKPOINTS = [640, 750, 828, 960, 1080, 1280, 1600, 1920];
+import {
+	buildResponsiveImage,
+	toAbsoluteMediaUrl,
+	RESPONSIVE_BREAKPOINTS,
+} from "../media/responsive.js";
+import { getPublicOrigin } from "../api/public-url.js";
 
 export interface Props {
 	node: {
@@ -44,7 +49,7 @@ function generateSrcset(
 	maxWidth: number,
 	aspectRatio?: number,
 ): string {
-	return BREAKPOINTS.filter((w) => w <= maxWidth * 2)
+	return RESPONSIVE_BREAKPOINTS.filter((w) => w <= maxWidth * 2)
 		.map((w) => {
 			const h = aspectRatio ? Math.round(w / aspectRatio) : undefined;
 			return `${getSrc({ width: w, height: h })} ${w}w`;
@@ -131,6 +136,18 @@ if (!src) {
 		url: asset.url,
 		id: asset._ref,
 	});
+	// Generate a responsive srcset via Astro's image service for local/R2 media.
+	// Falls back to the plain URL when optimization isn't possible.
+	const optimized = await buildResponsiveImage(getImage, {
+		src: toAbsoluteMediaUrl(src, getPublicOrigin(Astro.url, Astro.locals.emdash?.config)),
+		width: renderWidth,
+		height: renderHeight,
+	});
+	if (optimized) {
+		src = optimized.src;
+		srcset = optimized.srcset;
+		sizes = optimized.sizes;
+	}
 }
 
 // Build placeholder background style

package/src/database/migrations/043_content_references.ts

@@ -0,0 +1,121 @@
+import type { Kysely } from "kysely";
+
+import { getI18nConfig } from "../../i18n/config.js";
+import { currentTimestamp } from "../dialect-helpers.js";
+
+/**
+ * Content references.
+ *
+ * `_emdash_relations` defines relationship types (row-per-locale, mirroring
+ * `_emdash_taxonomy_defs`): which collection is the parent, which is the child
+ * (the side that may multiply), and localized labels for each role.
+ *
+ * `_emdash_content_references` holds directed `parent → child` edges between
+ * content entries. Both endpoints and the relation are referenced by
+ * `translation_group`, so edges are locale-agnostic. As with
+ * `content_taxonomies`, group-linking precludes SQL foreign keys; referential
+ * cleanup is an application-layer concern.
+ *
+ * Idempotency: every `CREATE TABLE` and `CREATE INDEX` uses `.ifNotExists()`,
+ * so a partial prior run (a crash mid-migration, or a retry after the runner's
+ * race-recovery path) re-applies cleanly — including any indexes that landed in
+ * the failed pass after their table.
+ */
+export async function up(db: Kysely<unknown>): Promise<void> {
+	const defaultLocale = getI18nConfig()?.defaultLocale ?? "en";
+
+	await db.schema
+		.createTable("_emdash_relations")
+		.ifNotExists()
+		.addColumn("id", "text", (c) => c.primaryKey())
+		.addColumn("name", "text", (c) => c.notNull())
+		.addColumn("parent_collection", "text", (c) => c.notNull())
+		.addColumn("child_collection", "text", (c) => c.notNull())
+		.addColumn("parent_label", "text", (c) => c.notNull())
+		.addColumn("child_label", "text", (c) => c.notNull())
+		.addColumn("locale", "text", (c) => c.notNull().defaultTo(defaultLocale))
+		.addColumn("translation_group", "text", (c) => c.notNull())
+		.addColumn("created_at", "text", (c) => c.defaultTo(currentTimestamp(db)))
+		.addColumn("updated_at", "text", (c) => c.defaultTo(currentTimestamp(db)))
+		.addUniqueConstraint("_emdash_relations_name_locale_unique", ["name", "locale"])
+		.execute();
+
+	await db.schema
+		.createIndex("idx__emdash_relations_locale")
+		.ifNotExists()
+		.on("_emdash_relations")
+		.column("locale")
+		.execute();
+	await db.schema
+		.createIndex("idx__emdash_relations_translation_group")
+		.ifNotExists()
+		.on("_emdash_relations")
+		.column("translation_group")
+		.execute();
+	await db.schema
+		.createIndex("idx__emdash_relations_parent_collection")
+		.ifNotExists()
+		.on("_emdash_relations")
+		.column("parent_collection")
+		.execute();
+	await db.schema
+		.createIndex("idx__emdash_relations_child_collection")
+		.ifNotExists()
+		.on("_emdash_relations")
+		.column("child_collection")
+		.execute();
+
+	// One row per (translation_group, locale): the row-per-locale model wants a
+	// relation to have at most one variant per locale. Migration 040 enforces
+	// the same invariant for `_emdash_bylines` with a *partial* unique
+	// (`WHERE translation_group IS NOT NULL`) only because it back-fills an
+	// existing table; this table is new and `translation_group` is `NOT NULL`,
+	// so a plain unique index suffices.
+	await db.schema
+		.createIndex("idx__emdash_relations_group_locale_unique")
+		.ifNotExists()
+		.unique()
+		.on("_emdash_relations")
+		.columns(["translation_group", "locale"])
+		.execute();
+
+	await db.schema
+		.createTable("_emdash_content_references")
+		.ifNotExists()
+		.addColumn("id", "text", (c) => c.primaryKey())
+		.addColumn("relation_group", "text", (c) => c.notNull())
+		.addColumn("parent_group", "text", (c) => c.notNull())
+		.addColumn("child_group", "text", (c) => c.notNull())
+		.addColumn("sort_order", "integer", (c) => c.notNull().defaultTo(0))
+		.addColumn("created_at", "text", (c) => c.defaultTo(currentTimestamp(db)))
+		.addUniqueConstraint("content_references_unique", [
+			"relation_group",
+			"parent_group",
+			"child_group",
+		])
+		.execute();
+
+	await db.schema
+		.createIndex("idx__emdash_content_references_parent")
+		.ifNotExists()
+		.on("_emdash_content_references")
+		.columns(["parent_group", "relation_group", "sort_order"])
+		.execute();
+	await db.schema
+		.createIndex("idx__emdash_content_references_child")
+		.ifNotExists()
+		.on("_emdash_content_references")
+		.columns(["child_group", "relation_group"])
+		.execute();
+	await db.schema
+		.createIndex("idx__emdash_content_references_relation")
+		.ifNotExists()
+		.on("_emdash_content_references")
+		.column("relation_group")
+		.execute();
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	await db.schema.dropTable("_emdash_content_references").ifExists().execute();
+	await db.schema.dropTable("_emdash_relations").ifExists().execute();
+}

package/src/database/migrations/runner.ts

@@ -44,6 +44,7 @@ import * as m039 from "./039_fix_fts5_triggers.js";
 import * as m040 from "./040_byline_i18n.js";
 import * as m041 from "./041_content_locale_list_index.js";
 import * as m042 from "./042_byline_fields.js";
+import * as m043 from "./043_content_references.js";
 
 const MIGRATIONS: Readonly<Record<string, Migration>> = Object.freeze({
 	"001_initial": m001,
@@ -87,6 +88,7 @@ const MIGRATIONS: Readonly<Record<string, Migration>> = Object.freeze({
 	"040_byline_i18n": m040,
 	"041_content_locale_list_index": m041,
 	"042_byline_fields": m042,
+	"043_content_references": m043,
 });
 
 /** Total number of registered migrations. Exported for use in tests. */