emdash 0.40.1 → 0.42.0

package/src/astro/routes/api/typegen.ts

@@ -13,51 +13,11 @@
  */
 
 import type { APIRoute } from "astro";
-import type { Kysely } from "kysely";
 
 import { apiError, apiSuccess, handleError } from "#api/error.js";
-import type { SchemaRegistry } from "#schema/registry.js";
-
-import type { Database } from "../../../database/types.js";
 
 export const prerender = false;
 
-/**
- * Safely list collections, returning empty array if tables don't exist yet
- */
-async function safeListCollections(registry: SchemaRegistry) {
-	try {
-		return await registry.listCollections();
-	} catch (error) {
-		// Handle missing tables for new sites that haven't run setup yet
-		if (error instanceof Error && error.message.includes("no such table")) {
-			return [];
-		}
-		throw error;
-	}
-}
-
-/**
- * Generate types content and metadata from the current schema.
- */
-async function generateTypes(registry: SchemaRegistry, db: Kysely<Database>) {
-	const { expandCollectionBlockFields } = await import("#schema/block-values.js");
-	const { generateTypesFile, generateSchemaHash } = await import("#schema/zod-generator.js");
-
-	const collections = await safeListCollections(registry);
-	const collectionsWithFields = await Promise.all(
-		collections.map(async (c) => {
-			const fields = await registry.listFields(c.id);
-			return expandCollectionBlockFields(db, { ...c, fields });
-		}),
-	);
-
-	const types = generateTypesFile(collectionsWithFields);
-	const hash: string = await generateSchemaHash(collectionsWithFields);
-
-	return { types, hash, collections: collections.length };
-}
-
 /**
  * GET - Return types as plain text (for preview/debugging)
  */
@@ -73,9 +33,8 @@ export const GET: APIRoute = async ({ locals }) => {
 	}
 
 	try {
-		const { SchemaRegistry } = await import("#schema/registry.js");
-		const registry = new SchemaRegistry(emdash.db);
-		const { types } = await generateTypes(registry, emdash.db);
+		const { generateEnvTypes } = await import("#schema/env-types.js");
+		const { types } = await generateEnvTypes(emdash.db);
 
 		return new Response(types, {
 			status: 200,
@@ -107,9 +66,8 @@ export const POST: APIRoute = async ({ locals }) => {
 	}
 
 	try {
-		const { SchemaRegistry } = await import("#schema/registry.js");
-		const registry = new SchemaRegistry(emdash.db);
-		const result = await generateTypes(registry, emdash.db);
+		const { generateEnvTypes } = await import("#schema/env-types.js");
+		const result = await generateEnvTypes(emdash.db);
 
 		return apiSuccess(result);
 	} catch (error) {

package/src/astro/session-user.ts

@@ -1,3 +1,6 @@
+import { apiError } from "#api/error.js";
+import { ErrorCode } from "#api/errors.js";
+
 import { after } from "../after.js";
 
 /**
@@ -55,3 +58,14 @@ export async function resolveSessionUser<T>(
 		clearTimeout(timer);
 	}
 }
+
+export const SESSION_UNAVAILABLE_MESSAGE =
+	"Sign-in needs an Astro session driver. Configure session.driver in astro.config.mjs.";
+
+/**
+ * Error for sign-in routes when Astro has no session to store the user in.
+ * Check before consuming tokens so a failed sign-in can be retried.
+ */
+export function sessionUnavailableError(): Response {
+	return apiError(ErrorCode.SESSION_UNAVAILABLE, SESSION_UNAVAILABLE_MESSAGE, 500);
+}

package/src/astro/types.ts

@@ -53,11 +53,15 @@ export interface ManifestCollection {
 	 * editor, and API keep working.
 	 */
 	hidden?: boolean;
+	/** Phosphor icon name for the sidebar entry (kebab-case, e.g. `calendar-blank`). */
+	icon?: string;
 	/**
 	 * Sidebar folder. Collections sharing a group render under one collapsible
 	 * entry labelled with the group.
 	 */
 	group?: string;
+	/** `false` omits the dashboard's "new entry" quick action. */
+	quickCreate?: boolean;
 	/** Valid custom field slugs to render in the admin content list. */
 	listColumns?: string[];
 	fields: Record<
@@ -197,6 +201,8 @@ export interface EmDashManifest {
 	 * browse or install flows.
 	 */
 	marketplace?: boolean;
+	/** Whether a sandbox runner is enabled for installing and running sandboxed plugins. */
+	sandboxEnabled?: boolean;
 	/**
 	 * Decentralized plugin registry configuration.
 	 *
@@ -237,6 +243,7 @@ export interface EmDashManifest {
 	admin?: {
 		logo?: string;
 		siteName?: string;
+		footerLabel?: string | false;
 		favicon?: string;
 	};
 }
@@ -304,6 +311,7 @@ export interface EmDashHandlers {
 		collection: string,
 		id: string,
 		locale?: string,
+		referenceOptions?: { includeDrafts: boolean },
 	) => Promise<
 		HandlerResponse<{
 			item: {
@@ -326,6 +334,7 @@ export interface EmDashHandlers {
 			locale?: string;
 			translationOf?: string;
 			taxonomies?: Record<string, string[]>;
+			references?: Record<string, string[]>;
 			createdAt?: string | null;
 			publishedAt?: string | null;
 			migrateBlocks?: boolean;
@@ -352,6 +361,7 @@ export interface EmDashHandlers {
 				noIndex?: boolean;
 			};
 			taxonomies?: Record<string, string[]>;
+			references?: Record<string, string[]>;
 			publishedAt?: string | null;
 			_rev?: string;
 			migrateBlocks?: boolean;
@@ -448,6 +458,7 @@ export interface EmDashHandlers {
 		url?: string;
 		contentType?: string;
 		alt?: string;
+		caption?: string;
 		authorId?: string;
 		maxUploadSize?: number;
 	}) => Promise<HandlerResponse>;

package/src/bylines/credits.ts

@@ -0,0 +1,149 @@
+import type { Kysely } from "kysely";
+
+import { BylineRepository } from "../database/repositories/byline.js";
+import type { BylineSummary, ContentBylineCredit } from "../database/repositories/types.js";
+import type { Database } from "../database/types.js";
+import { validateIdentifier } from "../database/validate.js";
+import { isMissingTableError } from "../utils/db-errors.js";
+
+/**
+ * Entry reference for batch byline lookups. Passing `authorId`,
+ * `primaryBylineId`, and `locale` in directly avoids a per-entry
+ * `SELECT` against the content table during hydration.
+ *
+ * `primaryBylineId` is the explicit-credit sentinel — non-null suppresses
+ * author fallback. `locale` drives the strict per-locale join.
+ */
+export interface BylineEntry {
+	id: string;
+	authorId: string | null;
+	primaryBylineId?: string | null;
+	locale?: string | null;
+}
+
+export interface ResolveBylineCreditsOptions {
+	/** Merge byline custom field values onto each credit. Defaults to `true`. */
+	hydrateCustomFields?: boolean;
+}
+
+/**
+ * Resolve byline credits for multiple content entries against an explicit
+ * database handle.
+ *
+ * Entries are bucketed by `entry.locale` and each bucket gets a single
+ * batched strict-locale credit query. Entries with no explicit credit fall
+ * back to the byline linked to their author, unless `primaryBylineId` is set.
+ * Items with no `locale` field (legacy / single-locale installs) share an
+ * unscoped bucket.
+ *
+ * Every requested entry ID is present in the result, with `[]` when the
+ * entry has no resolvable credit.
+ */
+export async function resolveBylineCredits(
+	db: Kysely<Database>,
+	collection: string,
+	entries: BylineEntry[],
+	options: ResolveBylineCreditsOptions = {},
+): Promise<Map<string, ContentBylineCredit[]>> {
+	validateIdentifier(collection, "collection");
+	const hydrateCustomFields = options.hydrateCustomFields ?? true;
+	const result = new Map<string, ContentBylineCredit[]>();
+
+	for (const { id } of entries) {
+		result.set(id, []);
+	}
+
+	if (entries.length === 0) {
+		return result;
+	}
+
+	const repo = new BylineRepository(db);
+
+	const buckets = new Map<string | null, BylineEntry[]>();
+	for (const entry of entries) {
+		const key = entry.locale ?? null;
+		const bucket = buckets.get(key);
+		if (bucket) bucket.push(entry);
+		else buckets.set(key, [entry]);
+	}
+
+	// Each fetch skips hydration so the union of returned bylines can be
+	// hydrated in a single batched pass below, keeping mixed-locale lists
+	// at one translatable and one group-shared custom-field query.
+	const explicitByEntry = new Map<string, ContentBylineCredit[]>();
+	const entriesNeedingAuthorCheck: BylineEntry[] = [];
+	const hydrationTargets: BylineSummary[] = [];
+	for (const [locale, bucket] of buckets) {
+		const localeOpt = locale ? { locale, skipHydration: true } : { skipHydration: true };
+		const bucketIds = bucket.map((e) => e.id);
+		let bylinesMap;
+		try {
+			bylinesMap = await repo.getContentBylinesMany(collection, bucketIds, localeOpt);
+		} catch (error) {
+			if (isMissingTableError(error)) return result;
+			throw error;
+		}
+		for (const [id, list] of bylinesMap) {
+			explicitByEntry.set(id, list);
+			for (const credit of list) hydrationTargets.push(credit.byline);
+		}
+
+		for (const entry of bucket) {
+			const hasResolved = bylinesMap.has(entry.id) && bylinesMap.get(entry.id)!.length > 0;
+			if (hasResolved) continue;
+			if (entry.authorId) entriesNeedingAuthorCheck.push(entry);
+		}
+	}
+
+	const fallbackByEntry = new Map<string, BylineSummary>();
+	if (entriesNeedingAuthorCheck.length > 0) {
+		const authorBuckets = new Map<string | null, BylineEntry[]>();
+		for (const entry of entriesNeedingAuthorCheck) {
+			if (entry.primaryBylineId) continue;
+			const key = entry.locale ?? null;
+			const bucket = authorBuckets.get(key);
+			if (bucket) bucket.push(entry);
+			else authorBuckets.set(key, [entry]);
+		}
+
+		for (const [locale, bucket] of authorBuckets) {
+			const localeOpt: { locale?: string; skipHydration: true } = locale
+				? { locale, skipHydration: true }
+				: { skipHydration: true };
+			const authorIds = bucket.map((e) => e.authorId).filter((id): id is string => id !== null);
+			const uniqueAuthorIds = [...new Set(authorIds)];
+			if (uniqueAuthorIds.length === 0) continue;
+			const authorBylineMap = await repo.findByUserIds(uniqueAuthorIds, localeOpt);
+			for (const entry of bucket) {
+				if (!entry.authorId) continue;
+				const f = authorBylineMap.get(entry.authorId);
+				if (f) {
+					fallbackByEntry.set(entry.id, f);
+					hydrationTargets.push(f);
+				}
+			}
+		}
+	}
+
+	if (hydrateCustomFields && hydrationTargets.length > 0) {
+		await repo.hydrateBylineCustomFields(hydrationTargets);
+	}
+
+	for (const { id } of entries) {
+		const explicit = explicitByEntry.get(id);
+		if (explicit && explicit.length > 0) {
+			result.set(
+				id,
+				explicit.map((c) => ({ ...c, source: "explicit" as const })),
+			);
+			continue;
+		}
+
+		const fallback = fallbackByEntry.get(id);
+		if (fallback) {
+			result.set(id, [{ byline: fallback, sortOrder: 0, roleLabel: null, source: "inferred" }]);
+		}
+	}
+
+	return result;
+}

package/src/bylines/index.ts

@@ -24,7 +24,7 @@ import { validateIdentifier } from "../database/validate.js";
 import { resolveLocaleChain } from "../i18n/resolve.js";
 import { getDb } from "../loader.js";
 import { requestCached } from "../request-cache.js";
-import { isMissingTableError } from "../utils/db-errors.js";
+import { resolveBylineCredits, type BylineEntry } from "./credits.js";
 
 /**
  * No-op — kept for API compatibility.
@@ -153,20 +153,7 @@ export async function getEntryBylines(
 	return [];
 }
 
-/**
- * Entry reference for batch byline lookups. Passing `authorId`,
- * `primaryBylineId`, and `locale` in directly avoids a per-entry
- * `SELECT` against the content table during hydration.
- *
- * `primaryBylineId` is the explicit-credit sentinel — non-null suppresses
- * author fallback. `locale` drives the strict per-locale join.
- */
-export interface BylineEntry {
-	id: string;
-	authorId: string | null;
-	primaryBylineId?: string | null;
-	locale?: string | null;
-}
+export type { BylineEntry } from "./credits.js";
 
 /**
  * Batch-fetch byline credits for multiple content entries.
@@ -191,133 +178,8 @@ export async function getBylinesForEntries(
 	entries: BylineEntry[],
 ): Promise<Map<string, ContentBylineCredit[]>> {
 	validateIdentifier(collection, "collection");
-	const result = new Map<string, ContentBylineCredit[]>();
-
-	for (const { id } of entries) {
-		result.set(id, []);
-	}
-
-	if (entries.length === 0) {
-		return result;
-	}
-
-	const db = await getDb();
-	const repo = new BylineRepository(db);
-
-	// Bucket entries by locale so each bucket fires a single strict-locale
-	// `getContentBylinesMany` call. Items with no locale field share a
-	// bucket keyed by null (no `WHERE locale = ?` applied — legacy
-	// pre-i18n shape).
-	const buckets = new Map<string | null, BylineEntry[]>();
-	for (const entry of entries) {
-		const key = entry.locale ?? null;
-		const bucket = buckets.get(key);
-		if (bucket) bucket.push(entry);
-		else buckets.set(key, [entry]);
-	}
-
-	// Sites with no bylines get an empty map back at the same cost as the
-	// previous "has any bylines" probe, without the extra round-trip.
-	// Pre-migration databases (bylines table missing) fall through to the
-	// `isMissingTableError` catch below and return empty.
-	//
-	// Each bucket's `getContentBylinesMany` call uses `skipHydration: true`
-	// so the per-bucket fetches return bylines with `customFields = {}`.
-	// We then hydrate the union of returned bylines in a SINGLE batched
-	// pass via `hydrateBylineCustomFields`. This keeps mixed-locale list
-	// hydration at one batched group-shared query (and one batched
-	// translatable query) per request, even when locale buckets reference
-	// disjoint translation_groups — the strict reading of the Phase 3
-	// query-count envelope.
-	const explicitByEntry = new Map<string, ContentBylineCredit[]>();
-	const entriesNeedingAuthorCheck: BylineEntry[] = [];
-	const hydrationTargets: BylineSummary[] = [];
-	for (const [locale, bucket] of buckets) {
-		const localeOpt = locale ? { locale, skipHydration: true } : { skipHydration: true };
-		const bucketIds = bucket.map((e) => e.id);
-		let bylinesMap;
-		try {
-			bylinesMap = await repo.getContentBylinesMany(collection, bucketIds, localeOpt);
-		} catch (error) {
-			if (isMissingTableError(error)) return result;
-			throw error;
-		}
-		for (const [id, list] of bylinesMap) {
-			explicitByEntry.set(id, list);
-			for (const credit of list) hydrationTargets.push(credit.byline);
-		}
-
-		for (const entry of bucket) {
-			const hasResolved = bylinesMap.has(entry.id) && bylinesMap.get(entry.id)!.length > 0;
-			if (hasResolved) continue;
-			if (entry.authorId) entriesNeedingAuthorCheck.push(entry);
-		}
-	}
-
-	// Only entries without an explicit credit (primaryBylineId null) are
-	// eligible for author fallback.
-	const fallbackByEntry = new Map<string, BylineSummary>();
-	if (entriesNeedingAuthorCheck.length > 0) {
-		const authorBuckets = new Map<string | null, BylineEntry[]>();
-		for (const entry of entriesNeedingAuthorCheck) {
-			if (entry.primaryBylineId) continue;
-			const key = entry.locale ?? null;
-			const bucket = authorBuckets.get(key);
-			if (bucket) bucket.push(entry);
-			else authorBuckets.set(key, [entry]);
-		}
-
-		for (const [locale, bucket] of authorBuckets) {
-			const localeOpt: { locale?: string; skipHydration: true } = locale
-				? { locale, skipHydration: true }
-				: { skipHydration: true };
-			const authorIds = bucket.map((e) => e.authorId).filter((id): id is string => id !== null);
-			const uniqueAuthorIds = [...new Set(authorIds)];
-			if (uniqueAuthorIds.length === 0) continue;
-			// `skipHydration: true` returns bylines with `customFields = {}`
-			// so the fallback path participates in the single batched
-			// `hydrateBylineCustomFields` call below — keeping the query
-			// envelope at "+1 group-shared query per hydration pass" even
-			// when author bylines across locale buckets reference disjoint
-			// translation_groups.
-			const authorBylineMap = await repo.findByUserIds(uniqueAuthorIds, localeOpt);
-			for (const entry of bucket) {
-				if (!entry.authorId) continue;
-				const f = authorBylineMap.get(entry.authorId);
-				if (f) {
-					fallbackByEntry.set(entry.id, f);
-					hydrationTargets.push(f);
-				}
-			}
-		}
-	}
-
-	// Single batched hydration over every byline returned from both the
-	// per-bucket explicit-credit fetches AND the per-bucket author-
-	// fallback fetches. One translatable query + one group-shared query
-	// for the whole pass, regardless of bucket count or whether
-	// translation_groups overlap across locales.
-	if (hydrationTargets.length > 0) {
-		await repo.hydrateBylineCustomFields(hydrationTargets);
-	}
-
-	for (const { id } of entries) {
-		const explicit = explicitByEntry.get(id);
-		if (explicit && explicit.length > 0) {
-			result.set(
-				id,
-				explicit.map((c) => ({ ...c, source: "explicit" as const })),
-			);
-			continue;
-		}
-
-		const fallback = fallbackByEntry.get(id);
-		if (fallback) {
-			result.set(id, [{ byline: fallback, sortOrder: 0, roleLabel: null, source: "inferred" }]);
-		}
-	}
-
-	return result;
+	if (entries.length === 0) return new Map();
+	return resolveBylineCredits(await getDb(), collection, entries);
 }
 
 /**