emdash 0.31.0 → 0.32.0

package/src/media/upload-attempts.ts

@@ -0,0 +1,33 @@
+import type { MediaRepository } from "../database/repositories/media.js";
+import type { Storage } from "../storage/types.js";
+
+export async function removeUploadAttempt(
+	storage: Storage,
+	repo: MediaRepository,
+	storageKey: string,
+	options: { allowUntracked?: boolean } = {},
+): Promise<boolean> {
+	try {
+		if (!(await repo.claimUploadAttemptForCleanup(storageKey))) {
+			const tracked = await repo.hasUploadAttempt(storageKey);
+			if (tracked || !options.allowUntracked) return false;
+		}
+	} catch (error) {
+		console.error("[media] upload cleanup claim failed:", error);
+		return false;
+	}
+
+	try {
+		await storage.delete(storageKey);
+	} catch (error) {
+		console.error("[media] upload cleanup failed:", error);
+		return false;
+	}
+
+	try {
+		await repo.deleteUploadAttempt(storageKey);
+	} catch (error) {
+		console.error("[media] upload cleanup record deletion failed:", error);
+	}
+	return true;
+}

package/src/query.ts

@@ -347,6 +347,23 @@ function entryEditOptions(entry: { data?: unknown }): EditableOptions {
 	return { status, hasDraft };
 }
 
+function stripRevisionMetadata(entry: { data?: unknown }): void {
+	const data = entryData(entry);
+	delete data.draftRevisionId;
+	delete data.liveRevisionId;
+}
+
+function canExposeRevisionMetadata(
+	entry: { id: string; data?: unknown },
+	collection: string,
+): boolean {
+	const ctx = getRequestContext();
+	if (ctx?.editMode) return true;
+	if (ctx?.preview?.collection !== collection) return false;
+	const dbId = entryDatabaseId(entry);
+	return ctx.preview.id === dbId || ctx.preview.id === entry.id;
+}
+
 /**
  * Get all entries of a content type
  *
@@ -441,7 +458,11 @@ async function loadCollectionCached<T extends string, D = InferCollectionData<T>
 		return { entries: [], error: snapshot.error, cacheHint: snapshot.cacheHint };
 	}
 	return {
-		entries: snapshot.value.entries.map((entry) => reviveEntry<D>(entry)),
+		entries: snapshot.value.entries.map((entry) => {
+			const revived = reviveEntry<D>(entry);
+			if (!canExposeRevisionMetadata(revived, type)) stripRevisionMetadata(revived);
+			return revived;
+		}),
 		nextCursor: snapshot.value.nextCursor,
 		hasMore: snapshot.value.hasMore,
 		cacheHint: snapshot.value.cacheHint,
@@ -729,6 +750,9 @@ async function getEmDashCollectionUncached<T extends string, D = InferCollection
 		if (isEditMode) {
 			tagEditableFields(entryData(entry), type, dbId);
 		}
+		if (!canExposeRevisionMetadata(entry, type)) {
+			stripRevisionMetadata(entry);
+		}
 		return {
 			...entry,
 			edit: isEditMode ? createEditable(type, dbId, entryEditOptions(entry)) : createNoop(),
@@ -833,6 +857,7 @@ export async function getEmDashEntry<T extends string, D = InferCollectionData<T
 		wrapped: ContentEntry<D>,
 		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
@@ -984,8 +1009,10 @@ export async function getEmDashEntry<T extends string, D = InferCollectionData<T
 	if (!snapshot.ok) {
 		return { entry: null, error: snapshot.error, isPreview: false, cacheHint: snapshot.cacheHint };
 	}
+	const revived = snapshot.value.entry ? reviveEntry<D>(snapshot.value.entry) : null;
+	if (revived && !canExposeRevisionMetadata(revived, type)) stripRevisionMetadata(revived);
 	return {
-		entry: snapshot.value.entry ? reviveEntry<D>(snapshot.value.entry) : null,
+		entry: revived,
 		isPreview: snapshot.value.isPreview,
 		fallbackLocale: snapshot.value.fallbackLocale,
 		cacheHint: snapshot.value.cacheHint,

package/src/storage/s3.ts

@@ -306,7 +306,7 @@ export class S3Storage implements Storage {
 				method: "PUT",
 				headers: {
 					"Content-Type": options.contentType,
-					...(options.size ? { "Content-Length": String(options.size) } : {}),
+					...(options.size !== undefined ? { "Content-Length": String(options.size) } : {}),
 				},
 				expiresAt,
 			};

package/src/taxonomies/index.ts

@@ -31,6 +31,15 @@ export interface TaxonomyQueryOptions {
 	locale?: string;
 }
 
+export interface TaxonomyTermsOptions extends TaxonomyQueryOptions {
+	/**
+	 * Populate each term's `count`. Counts aggregate the whole
+	 * `content_taxonomies` pivot against every declared collection, so callers
+	 * that don't render a count should opt out. Defaults to `true`.
+	 */
+	includeCounts?: boolean;
+}
+
 /** Invalidate cached taxonomy term data and any content that hydrates terms. */
 export function invalidateTermCache(): void {
 	invalidateTaxonomyObjectCache();
@@ -230,21 +239,54 @@ function termCountNamespaces(collections: string[]): string[] {
 /**
  * All terms of a taxonomy in a specific locale (flat for non-hierarchical,
  * tree for hierarchical).
+ *
+ * The term list and the visible-entry counts are loaded and cached separately:
+ * the list depends only on the taxonomy epoch, while the counts additionally
+ * depend on every counted collection's content epoch and cost an aggregate over
+ * the whole assignment pivot. Callers that don't render counts pass
+ * `includeCounts: false` and skip that aggregate entirely, while still sharing
+ * the term list with callers that do.
  */
 export async function getTaxonomyTerms(
 	taxonomyName: string,
-	options: TaxonomyQueryOptions = {},
+	options: TaxonomyTermsOptions = {},
 ): Promise<TaxonomyTerm[]> {
 	const locale = resolveLocale(options.locale);
-	return requestCached(`taxonomy-terms:${taxonomyName}:${locale ?? "*"}`, async () => {
-		const def = await getTaxonomyDef(taxonomyName, options);
-		if (!def) return [];
-		return cachedQuery({
-			namespace: termCountNamespaces(def.collections),
-			key: `terms:${taxonomyName}:${locale ?? "*"}`,
+	const def = await getTaxonomyDef(taxonomyName, options);
+	if (!def) return [];
+	if (options.includeCounts === false) return getTermList(def, locale);
+
+	// The two are independent, so run them concurrently to save a round trip.
+	const [terms, counts] = await Promise.all([
+		getTermList(def, locale),
+		getVisibleTermCounts(def.name, def.collections),
+	]);
+	return withCounts(terms, counts);
+}
+
+/** Terms without counts, under the cache keys the layout prefetch warms. */
+function getTermList(def: TaxonomyDef, locale: string | undefined): Promise<TaxonomyTerm[]> {
+	const localeKey = locale ?? "*";
+	return requestCached(`taxonomy-terms:${def.name}:${localeKey}`, () =>
+		cachedQuery({
+			namespace: CacheNamespace.TAXONOMIES,
+			key: `termList:${def.name}:${localeKey}`,
 			load: () => loadTaxonomyTerms(def, locale),
-		});
-	});
+		}),
+	);
+}
+
+/**
+ * Copy a term list with counts attached. Counts are keyed by translation_group
+ * (what the pivot stores) and are locale-independent. Rebuilds every node so
+ * the shared, cached count-free list is never mutated.
+ */
+function withCounts(terms: TaxonomyTerm[], counts: Map<string, number>): TaxonomyTerm[] {
+	return terms.map((term) => ({
+		...term,
+		count: counts.get(term.translationGroup ?? term.id) ?? 0,
+		children: withCounts(term.children, counts),
+	}));
 }
 
 async function loadTaxonomyTerms(
@@ -260,14 +302,7 @@ async function loadTaxonomyTerms(
 		.orderBy("label", "asc");
 	if (locale !== undefined) termsQuery = termsQuery.where("locale", "=", locale);
 
-	// Counts are keyed by translation_group (what the pivot stores) and are
-	// locale-independent. Only publicly visible entries are counted (#581);
-	// the map is request-cached so a term detail rendered on the same page
-	// reuses it. Independent of the terms query, so run both concurrently.
-	const [rows, counts] = await Promise.all([
-		termsQuery.execute(),
-		getVisibleTermCounts(def.name, def.collections),
-	]);
+	const rows = await termsQuery.execute();
 
 	const flatTerms: TaxonomyTermRow[] = rows.map((row) => ({
 		id: row.id,
@@ -280,7 +315,7 @@ async function loadTaxonomyTerms(
 		translation_group: row.translation_group,
 	}));
 
-	if (def.hierarchical) return buildTree(flatTerms, counts);
+	if (def.hierarchical) return buildTree(flatTerms);
 
 	return flatTerms.map((term) => ({
 		id: term.id,
@@ -289,7 +324,6 @@ async function loadTaxonomyTerms(
 		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,
 		translationGroup: term.translation_group,
 	}));
@@ -312,8 +346,16 @@ function getVisibleTermCounts(
 	// entry.
 	const scope = [...new Set(collections)].toSorted().join(",");
 	return requestCached(`taxonomy-term-counts:${taxonomyName}:${scope}`, async () => {
-		const db = await getDb();
-		return fetchVisibleTermCounts(db, taxonomyName, collections);
+		// A Map is not JSON-representable — cache the entries, rebuild on read.
+		const entries = await cachedQuery({
+			namespace: termCountNamespaces(collections),
+			key: `termCounts:${taxonomyName}:${scope}`,
+			load: async (): Promise<Array<[string, number]>> => {
+				const db = await getDb();
+				return [...(await fetchVisibleTermCounts(db, taxonomyName, collections))];
+			},
+		});
+		return new Map(entries);
 	});
 }
 
@@ -796,7 +838,7 @@ function rowToTaxonomyDef(row: {
 /**
  * Build tree structure from flat terms
  */
-function buildTree(flatTerms: TaxonomyTermRow[], counts: Map<string, number>): TaxonomyTerm[] {
+function buildTree(flatTerms: TaxonomyTermRow[]): TaxonomyTerm[] {
 	// parent_id holds the parent's translation_group, so link children by it.
 	// Key by (locale, group): a child's parent lives in the same locale, and an
 	// unfiltered set mixes locales whose translated siblings share a group —
@@ -814,7 +856,6 @@ function buildTree(flatTerms: TaxonomyTermRow[], counts: Map<string, number>): T
 			parentId: term.parent_id ?? undefined,
 			description: term.data ? JSON.parse(term.data).description : undefined,
 			children: [],
-			count: counts.get(term.translation_group ?? term.id) ?? 0,
 			locale: term.locale,
 			translationGroup: term.translation_group,
 		};

package/src/taxonomies/term-counts.ts

@@ -11,16 +11,17 @@
  * visibility at query time rather than trusting a literal status value.
  *
  * The public render path is latency-sensitive on D1, so per-collection counts
- * are combined into a single round-trip with UNION ALL — one query per
- * taxonomy, never one per collection.
+ * are combined with UNION ALL — one query per taxonomy, never one per
+ * collection, split only where the backend caps compound-SELECT terms.
  */
 
 import type { Kysely } from "kysely";
 import { sql } from "kysely";
 
-import { buildStatusCondition } from "../database/dialect-helpers.js";
+import { buildStatusCondition, compoundSelectLimit } from "../database/dialect-helpers.js";
 import type { Database } from "../database/types.js";
 import { validateIdentifier } from "../database/validate.js";
+import { chunks } from "../utils/chunks.js";
 import { isMissingTableError } from "../utils/db-errors.js";
 
 interface CountRow {
@@ -37,6 +38,10 @@ interface CountRow {
  * join on `taxonomies.id` — the anchor row (id == group) can be deleted while
  * sibling translations survive, and a plain join on `translation_group` would
  * multiply counts by the number of locales.
+ *
+ * CROSS JOIN with the join predicate in WHERE keeps stats-blind SQLite/D1 from
+ * reordering content_taxonomies out of the outer position; it touches ec_* only
+ * by primary key. Postgres treats this as an ordinary inner join and plans freely.
  */
 function collectionBranch(
 	db: Kysely<Database>,
@@ -46,8 +51,9 @@ function collectionBranch(
 	return sql`
 		SELECT ct.taxonomy_id AS taxonomy_id, COUNT(*) AS count
 		FROM content_taxonomies AS ct
-		INNER JOIN ${sql.ref(`ec_${collection}`)} AS e ON e.id = ct.entry_id
-		WHERE ct.collection = ${collection}
+		CROSS JOIN ${sql.ref(`ec_${collection}`)} AS e
+		WHERE e.id = ct.entry_id
+			AND ct.collection = ${collection}
 			AND ct.taxonomy_id IN (SELECT translation_group FROM taxonomies WHERE name = ${taxonomyName})
 			AND ${buildStatusCondition(db, "published", "e")}
 			AND e.deleted_at IS NULL
@@ -71,6 +77,36 @@ async function runCounts(
 	return counts;
 }
 
+function addCounts(into: Map<string, number>, from: Map<string, number>): void {
+	for (const [group, count] of from) into.set(group, (into.get(group) ?? 0) + count);
+}
+
+/**
+ * Counts for one batch of collections, degrading to a query per collection
+ * when a declared collection has no ec_* table so the rest still contribute.
+ */
+async function runBatch(
+	db: Kysely<Database>,
+	taxonomyName: string,
+	collections: string[],
+): Promise<Map<string, number>> {
+	try {
+		return await runCounts(db, taxonomyName, collections);
+	} catch (error) {
+		if (!isMissingTableError(error)) throw error;
+	}
+
+	const counts = new Map<string, number>();
+	for (const collection of collections) {
+		try {
+			addCounts(counts, await runCounts(db, taxonomyName, [collection]));
+		} catch (error) {
+			if (!isMissingTableError(error)) throw error;
+		}
+	}
+	return counts;
+}
+
 /**
  * Count publicly-visible term assignments for one taxonomy, keyed by the
  * term's translation_group (what `content_taxonomies.taxonomy_id` stores).
@@ -82,9 +118,15 @@ async function runCounts(
  * rather than a throw.
  *
  * One database round-trip for the whole taxonomy (UNION ALL across
- * collections). Callers on the public render path should go through the
- * request-cached wrapper in `taxonomies/index.ts` so a page rendering both the
- * widget and a term detail shares one computation.
+ * collections). On a backend that caps compound-SELECT terms — D1 allows five
+ * — the branches are split into one statement per batch, since a taxonomy
+ * declaring more collections than that would otherwise take down every path
+ * that shows counts. Per-collection sums are commutative, so batching cannot
+ * change the total.
+ *
+ * Callers on the public render path should go through the request-cached
+ * wrapper in `taxonomies/index.ts` so a page rendering both the widget and a
+ * term detail shares one computation.
  */
 export async function fetchVisibleTermCounts(
 	db: Kysely<Database>,
@@ -95,23 +137,11 @@ export async function fetchVisibleTermCounts(
 	for (const collection of unique) validateIdentifier(collection, "collection slug");
 	if (unique.length === 0) return new Map();
 
-	try {
-		return await runCounts(db, taxonomyName, unique);
-	} catch (error) {
-		if (!isMissingTableError(error)) throw error;
-	}
+	const limit = compoundSelectLimit(db);
+	const batched = limit === null ? [unique] : chunks(unique, limit);
+	const batches = await Promise.all(batched.map((batch) => runBatch(db, taxonomyName, batch)));
 
-	// A declared collection has no ec_* table — retry per collection so the
-	// existing tables still contribute (still scheduled-aware + deleted_at).
 	const counts = new Map<string, number>();
-	for (const collection of unique) {
-		try {
-			for (const [group, count] of await runCounts(db, taxonomyName, [collection])) {
-				counts.set(group, (counts.get(group) ?? 0) + count);
-			}
-		} catch (error) {
-			if (!isMissingTableError(error)) throw error;
-		}
-	}
+	for (const batch of batches) addCounts(counts, batch);
 	return counts;
 }

package/src/utils/hash.ts

@@ -1,3 +1,10 @@
+export const MAX_CONTENT_HASH_BYTES = 8 * 1024 * 1024;
+
+function formatContentHash(hash: Uint8Array): string {
+	const hashHex = Array.from(hash, (byte) => byte.toString(16).padStart(2, "0")).join("");
+	return `sha1:${hashHex}`;
+}
+
 /**
  * SHA-256 hash of a string, truncated to 16 hex chars (64 bits).
  * For cache invalidation / ETags — not for security.
@@ -25,12 +32,16 @@ export async function computeContentHash(content: Uint8Array | ArrayBuffer): Pro
 	let buf: ArrayBuffer;
 	if (content instanceof ArrayBuffer) {
 		buf = content;
+	} else if (
+		content.buffer instanceof ArrayBuffer &&
+		content.byteOffset === 0 &&
+		content.byteLength === content.buffer.byteLength
+	) {
+		buf = content.buffer;
 	} else {
 		buf = new ArrayBuffer(content.byteLength);
 		new Uint8Array(buf).set(content);
 	}
 	const hashBuffer = await crypto.subtle.digest("SHA-1", buf);
-	const hashArray = new Uint8Array(hashBuffer);
-	const hashHex = Array.from(hashArray, (b) => b.toString(16).padStart(2, "0")).join("");
-	return `sha1:${hashHex}`;
+	return formatContentHash(new Uint8Array(hashBuffer));
 }