emdash 0.31.1 → 0.32.0

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/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));
 }