emdash 1.2.0 → 1.3.0

package/src/database/repositories/plugin-storage.ts

@@ -37,10 +37,16 @@ import type {
 	ConditionalDeleteResult,
 } from "../../plugins/types.js";
 import { chunks, SQL_BATCH_SIZE } from "../../utils/chunks.js";
-import { pluginDataWriteExpr, pluginDataUpdateGuard } from "../dialect-helpers.js";
+import { isPostgres, pluginDataWriteExpr, pluginDataUpdateGuard } from "../dialect-helpers.js";
 import { withTransaction } from "../transaction.js";
 import type { Database } from "../types.js";
-import { encodeCursor, decodeCursor } from "./types.js";
+import {
+	encodeCursor,
+	decodeCursor,
+	InvalidCursorError,
+	MAX_CURSOR_LENGTH,
+	type SortFieldBoundary,
+} from "./types.js";
 
 /**
  * SQLSTATEs a losing concurrent `updateIf` writer can abort with.
@@ -114,6 +120,54 @@ function nullRank(expr: RawBuilder<unknown>): RawBuilder<number> {
 	return sql`(case when ${expr} is null then 1 else 0 end)`;
 }
 
+/**
+ * Comparison value for an orderBy cursor, matching the type of the ordered
+ * JSON expression.
+ *
+ * On Postgres the order expression is jsonb, so non-missing cursor values are
+ * cast to jsonb. This is important for explicit JSON `null`: the bound value
+ * must be the jsonb `null` scalar, not SQL NULL, because Postgres
+ * `data::jsonb->'field'` returns jsonb `null` for an explicit null and SQL NULL
+ * for a missing key. SQLite extracts SQL NULL for both cases, so a missing
+ * boundary and an explicit null both bind SQL NULL.
+ */
+function cursorFieldValue(db: Kysely<Database>, boundary: SortFieldBoundary): RawBuilder<unknown> {
+	if (boundary.missing) {
+		return sql`null`;
+	}
+	if (isPostgres(db)) {
+		return sql`${sql.val(JSON.stringify(boundary.value))}::jsonb`;
+	}
+	return sql.val(boundary.value);
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function sortBoundaries(data: unknown, orderFields: string[]): SortFieldBoundary[] {
+	const record = isRecord(data) ? data : undefined;
+	return orderFields.map((field) => {
+		if (record !== undefined && Object.hasOwn(record, field)) {
+			return { value: record[field], missing: false };
+		}
+		return { missing: true };
+	});
+}
+
+function isScalarSortBoundary(boundary: SortFieldBoundary): boolean {
+	if (boundary.missing) {
+		return true;
+	}
+	const value = boundary.value;
+	return (
+		value === null ||
+		typeof value === "string" ||
+		typeof value === "number" ||
+		typeof value === "boolean"
+	);
+}
+
 export class PluginStorageRepository<T = unknown> implements StorageCollection<T> {
 	private indexedFields: Set<string>;
 
@@ -403,15 +457,43 @@ export class PluginStorageRepository<T = unknown> implements StorageCollection<T
 					);
 				}
 				const op = descending ? sql`<` : sql`>`;
-				// The cursor row's sort values, recomputed with the same expression
-				// rather than carried in the cursor, so nothing is bound as a literal
-				// and neither dialect has to coerce a JSON value to compare it.
+				const cursorSortValues = decoded.sortValues;
+
+				// New cursors carry the ordered field values so paging survives deletion
+				// of the anchor row. Legacy cursors fall back to re-reading the anchor;
+				// if it has been deleted we can no longer compute the seek boundary, so
+				// we surface a clear error instead of returning a wrong page.
+				//
+				// SQLite's json_extract returns scalar values, so cursors that encode
+				// objects or arrays cannot be bound as query parameters there. On any
+				// dialect we also skip cursor-bound values when they would make the
+				// cursor exceed the length cap, and fall back to the anchor lookup.
+				const useCursorValues =
+					cursorSortValues !== undefined &&
+					cursorSortValues.length === orderEntries.length &&
+					(isPostgres(this.db) || cursorSortValues.every(isScalarSortBoundary));
+
 				const cursorExpr = (field: string): RawBuilder<unknown> =>
 					sql`(select ${sql.raw(jsonOrderExtract(this.db, field))} from _plugin_storage where plugin_id = ${this.pluginId} and collection = ${this.collection} and id = ${decoded.id})`;
 
-				const fields = orderEntries.map(([field]) => {
+				if (!useCursorValues) {
+					const anchorExists = await this.db
+						.selectFrom("_plugin_storage")
+						.select(sql`1`.as("one"))
+						.where("plugin_id", "=", this.pluginId)
+						.where("collection", "=", this.collection)
+						.where("id", "=", decoded.id)
+						.executeTakeFirst();
+					if (!anchorExists) {
+						throw new InvalidCursorError(cursor);
+					}
+				}
+
+				const fields = orderEntries.map(([field], index) => {
 					const own = sortExpr(field);
-					const theirs = cursorExpr(field);
+					const theirs = useCursorValues
+						? cursorFieldValue(this.db, cursorSortValues[index])
+						: cursorExpr(field);
 					return {
 						equal: sql`(${nullRank(own)} = ${nullRank(theirs)} and (${nullRank(own)} = 1 or ${own} = ${theirs}))`,
 						after: sql`(${nullRank(own)} ${op} ${nullRank(theirs)} or (${nullRank(own)} = ${nullRank(theirs)} and ${nullRank(own)} = 0 and ${own} ${op} ${theirs}))`,
@@ -466,7 +548,26 @@ export class PluginStorageRepository<T = unknown> implements StorageCollection<T
 		if (hasMore) {
 			const lastItem = rows[limit - 1];
 			if (lastItem) {
-				nextCursor = encodeCursor(lastItem.created_at, lastItem.id);
+				let sortValues: SortFieldBoundary[] | undefined;
+				if (orderEntries.length > 0) {
+					const parsed: unknown = JSON.parse(lastItem.data);
+					const candidate = sortBoundaries(
+						parsed,
+						orderEntries.map(([field]) => field),
+					);
+					// Only encode scalar boundaries. Non-scalar values cannot be bound
+					// on SQLite, and large values can blow past the cursor length cap.
+					// In both cases we fall back to the legacy anchor-row lookup.
+					if (candidate.every(isScalarSortBoundary)) {
+						sortValues = candidate;
+					}
+				}
+				nextCursor = encodeCursor(lastItem.created_at, lastItem.id, sortValues);
+				// If the scalar values still produced an oversized cursor, drop them
+				// and rely on the anchor row instead.
+				if (nextCursor.length > MAX_CURSOR_LENGTH) {
+					nextCursor = encodeCursor(lastItem.created_at, lastItem.id, undefined);
+				}
 			}
 		}
 

package/src/database/repositories/revision.ts

@@ -20,6 +20,17 @@ export interface Revision {
 	createdAt: string;
 }
 
+export interface RevisionAuthor {
+	id: string;
+	/** `null` when the account has no display name. */
+	name: string | null;
+}
+
+export interface RevisionWithAuthor extends Revision {
+	/** `null` when no author was recorded or the account no longer exists. */
+	author: RevisionAuthor | null;
+}
+
 export interface CreateRevisionInput {
 	collection: string;
 	entryId: string;
@@ -136,13 +147,15 @@ export class RevisionRepository {
 		collection: string,
 		entryId: string,
 		options: { limit?: number } = {},
-	): Promise<Revision[]> {
+	): Promise<RevisionWithAuthor[]> {
 		let query = this.db
 			.selectFrom("revisions")
-			.selectAll()
-			.where("collection", "=", collection)
-			.where("entry_id", "=", entryId)
-			.orderBy("id", "desc");
+			.leftJoin("users", "users.id", "revisions.author_id")
+			.selectAll("revisions")
+			.select(["users.id as author_user_id", "users.name as author_name"])
+			.where("revisions.collection", "=", collection)
+			.where("revisions.entry_id", "=", entryId)
+			.orderBy("revisions.id", "desc");
 
 		if (options.limit) {
 			query = query.limit(options.limit);
@@ -156,7 +169,12 @@ export class RevisionRepository {
 		return rows.map((row, index) => {
 			const normalized = data[index];
 			if (!normalized) throw new Error("Failed to normalize revision data");
-			return this.rowToRevision(row, normalized);
+			return {
+				...this.rowToRevision(row, normalized),
+				author: row.author_user_id
+					? { id: row.author_user_id, name: row.author_name?.trim() || null }
+					: null,
+			};
 		});
 	}
 

package/src/database/repositories/types.ts

@@ -10,7 +10,7 @@ import { encodeBase64, decodeBase64 } from "../../utils/base64.js";
  * REST schemas also clamp at 2048 — this 4096 cap is a defense-in-depth
  * floor inside the repository helpers.
  */
-const MAX_CURSOR_LENGTH = 4096;
+export const MAX_CURSOR_LENGTH = 4096;
 
 export interface CreateContentInput {
 	/** Explicit content ID for stable seed imports. Omit to generate a ULID. */
@@ -250,9 +250,33 @@ export interface FindManyResult<T> {
  */
 export const STAGED_CURSOR_MARKER = "staged";
 
-/** Encode a cursor from order value + id */
-export function encodeCursor(orderValue: string, id: string): string {
-	return encodeBase64(JSON.stringify({ orderValue, id }));
+/**
+ * Boundary for a single ordered field inside a cursor.
+ *
+ * `missing` distinguishes "the document has no value for this field" from
+ * "the document stores JSON `null`". SQLite can only tell these apart at the
+ * SQL layer, but PostgreSQL orders `data::jsonb->'field'` differently for the
+ * two cases, so the seek boundary must carry both possibilities.
+ */
+export interface SortFieldBoundary {
+	value?: unknown;
+	missing?: boolean;
+}
+
+/** Encode a cursor from order value + id, optionally carrying the ordered field values. */
+export function encodeCursor(
+	orderValue: string,
+	id: string,
+	sortValues?: SortFieldBoundary[],
+): string {
+	const payload: { orderValue: string; id: string; sortValues?: SortFieldBoundary[] } = {
+		orderValue,
+		id,
+	};
+	if (sortValues !== undefined && sortValues.length > 0) {
+		payload.sortValues = sortValues;
+	}
+	return encodeBase64(JSON.stringify(payload));
 }
 
 /**
@@ -271,13 +295,36 @@ export class InvalidCursorError extends Error {
 	}
 }
 
+function isSortFieldBoundary(item: unknown): item is SortFieldBoundary {
+	if (item === null || typeof item !== "object") {
+		return false;
+	}
+	const candidate = item as { value?: unknown; missing?: unknown };
+	if (candidate.missing !== undefined && typeof candidate.missing !== "boolean") {
+		return false;
+	}
+	return true;
+}
+
+function normalizeSortBoundary(item: unknown): SortFieldBoundary {
+	if (isSortFieldBoundary(item)) {
+		return { value: item.value, missing: item.missing };
+	}
+	// Fall back for plain values that predate the structured boundary format.
+	return { value: item, missing: false };
+}
+
 /**
  * Decode a cursor to order value + id.
  *
  * Throws `InvalidCursorError` if the cursor is empty, not valid base64,
  * not valid JSON, or doesn't contain string `orderValue` and `id` fields.
  */
-export function decodeCursor(cursor: string): { orderValue: string; id: string } {
+export function decodeCursor(cursor: string): {
+	orderValue: string;
+	id: string;
+	sortValues?: SortFieldBoundary[];
+} {
 	if (!cursor) throw new InvalidCursorError(cursor);
 	if (cursor.length > MAX_CURSOR_LENGTH) throw new InvalidCursorError(cursor);
 	let parsed: unknown;
@@ -289,11 +336,22 @@ export function decodeCursor(cursor: string): { orderValue: string; id: string }
 	if (parsed === null || typeof parsed !== "object") {
 		throw new InvalidCursorError(cursor);
 	}
-	const candidate = parsed as { orderValue?: unknown; id?: unknown };
+	const candidate = parsed as { orderValue?: unknown; id?: unknown; sortValues?: unknown };
 	if (typeof candidate.orderValue !== "string" || typeof candidate.id !== "string") {
 		throw new InvalidCursorError(cursor);
 	}
-	return { orderValue: candidate.orderValue, id: candidate.id };
+	let sortValues: SortFieldBoundary[] | undefined;
+	if (candidate.sortValues !== undefined) {
+		if (!Array.isArray(candidate.sortValues)) {
+			throw new InvalidCursorError(cursor);
+		}
+		sortValues = candidate.sortValues.map(normalizeSortBoundary);
+	}
+	return {
+		orderValue: candidate.orderValue,
+		id: candidate.id,
+		sortValues,
+	};
 }
 
 export interface ContentItem {