emdash 0.40.1 → 0.42.0

package/src/database/repositories/content.ts

@@ -5,7 +5,7 @@ import type { ContentFieldFilterValue, ContentFieldFilters } from "../../content
 import { keepKnownFields, staleStoredKeys } from "../../content/known-fields.js";
 import { normalizeExplicitDatetime } from "../../datetime-normalization.js";
 import { invalidateCollectionCache } from "../../object-cache/index.js";
-import { isIndexableFieldType, type FieldType } from "../../schema/types.js";
+import { isIndexableFieldType, isStoragelessFieldRow, type FieldType } from "../../schema/types.js";
 import { buildFtsPrefixMatch, buildSlugGlobPrefix } from "../../search/match.js";
 import { chunks, SQL_BATCH_SIZE } from "../../utils/chunks.js";
 import { isMissingTableError } from "../../utils/db-errors.js";
@@ -350,7 +350,7 @@ export class ContentRepository {
 			publishedAt,
 			createdAt,
 		} = input;
-		const data = await this.datetimes.normalizeData(type, inputData);
+		const data = await this.datetimes.normalizeInput(type, inputData);
 		const normalizedCreatedAt = createdAt
 			? await this.datetimes.normalizeValue(type, createdAt)
 			: now;
@@ -578,14 +578,19 @@ export class ContentRepository {
 		return this.mapRow(type, row);
 	}
 
-	async findManyByIds(type: string, ids: string[]): Promise<Map<string, ContentItem>> {
+	async findManyByIds(
+		type: string,
+		ids: string[],
+		options: { includeTrashed?: boolean } = {},
+	): Promise<Map<string, ContentItem>> {
 		const items = new Map<string, ContentItem>();
 		if (ids.length === 0) return items;
 		const tableName = getTableName(type);
+		const deletedFilter = options.includeTrashed ? sql`` : sql`AND deleted_at IS NULL`;
 		for (const batch of chunks([...new Set(ids)], SQL_BATCH_SIZE)) {
 			const result = await sql<Record<string, unknown>>`
 				SELECT * FROM ${sql.ref(tableName)}
-				WHERE id IN (${sql.join(batch)}) AND deleted_at IS NULL
+				WHERE id IN (${sql.join(batch)}) ${deletedFilter}
 			`.execute(this.db);
 			for (const row of result.rows) {
 				const item = this.mapRow(type, row);
@@ -599,14 +604,16 @@ export class ContentRepository {
 		type: string,
 		slugs: string[],
 		locale: string,
+		options: { includeTrashed?: boolean } = {},
 	): Promise<Map<string, ContentItem>> {
 		const items = new Map<string, ContentItem>();
 		if (slugs.length === 0) return items;
 		const tableName = getTableName(type);
+		const deletedFilter = options.includeTrashed ? sql`` : sql`AND deleted_at IS NULL`;
 		for (const batch of chunks([...new Set(slugs)], SQL_BATCH_SIZE)) {
 			const result = await sql<Record<string, unknown>>`
 				SELECT * FROM ${sql.ref(tableName)}
-				WHERE slug IN (${sql.join(batch)}) AND locale = ${locale} AND deleted_at IS NULL
+				WHERE slug IN (${sql.join(batch)}) AND locale = ${locale} ${deletedFilter}
 			`.execute(this.db);
 			for (const row of result.rows) {
 				const item = this.mapRow(type, row);
@@ -619,8 +626,15 @@ export class ContentRepository {
 	/**
 	 * Find content by id, including trashed (soft-deleted) items.
 	 * Used by restore endpoint for ownership checks.
+	 *
+	 * `deletedAt` rides along because the row is already in hand: a caller that
+	 * has to know whether the row is trashed before touching anything else would
+	 * otherwise pay a second read for a column this row already carries.
 	 */
-	async findByIdIncludingTrashed(type: string, id: string): Promise<ContentItem | null> {
+	async findByIdIncludingTrashed(
+		type: string,
+		id: string,
+	): Promise<(ContentItem & { deletedAt: string | null }) | null> {
 		const tableName = getTableName(type);
 
 		const result = await sql<Record<string, unknown>>`
@@ -633,7 +647,10 @@ export class ContentRepository {
 			return null;
 		}
 
-		return this.mapRow(type, row);
+		return {
+			...this.mapRow(type, row),
+			deletedAt: typeof row.deleted_at === "string" ? row.deleted_at : null,
+		};
 	}
 
 	/**
@@ -778,7 +795,7 @@ export class ContentRepository {
 		options: FindManyOptions = {},
 	): Promise<FindManyResult<ContentItem>> {
 		const tableName = getTableName(type);
-		const limit = Math.min(options.limit || 50, 100);
+		const limit = Math.max(1, Math.min(options.limit || 50, 100));
 
 		// Determine ordering
 		const orderField = options.orderBy?.field || "createdAt";
@@ -979,7 +996,7 @@ export class ContentRepository {
 
 		// Update data fields (skip system columns to prevent injection via data)
 		if (input.data !== undefined && typeof input.data === "object") {
-			const data = await this.datetimes.normalizeData(type, writableContentData(input.data));
+			const data = await this.datetimes.normalizeInput(type, writableContentData(input.data));
 			for (const [key, value] of Object.entries(data)) {
 				updates[key] = serializeValue(value);
 			}
@@ -1019,7 +1036,12 @@ export class ContentRepository {
 		if (!existing) throw new EmDashValidationError("Content item not found");
 
 		const normalizedSnapshot = await this.datetimes.normalizeData(type, revisionData);
-		const { _slug, ...snapshotFields } = normalizedSnapshot;
+		const { _slug } = normalizedSnapshot;
+		// Leading-underscore keys are staged metadata (`_slug`, `_references`), not columns.
+		const snapshotFields: Record<string, unknown> = {};
+		for (const [key, value] of Object.entries(normalizedSnapshot)) {
+			if (!key.startsWith("_")) snapshotFields[key] = value;
+		}
 		const fieldData = writableContentData(snapshotFields);
 		const revisionId = createRevisionId();
 		const now = new Date().toISOString();
@@ -1191,7 +1213,7 @@ export class ContentRepository {
 		input: UpdateContentInput,
 	): Promise<ContentItem> {
 		const data = input.data
-			? await this.datetimes.normalizeData(type, writableContentData(input.data))
+			? await this.datetimes.normalizeInput(type, writableContentData(input.data))
 			: {};
 		const stagedSlug = typeof input.slug === "string" ? input.slug : undefined;
 		const hasDraftUpdate = Object.keys(data).length > 0 || stagedSlug !== undefined;
@@ -1619,7 +1641,7 @@ export class ContentRepository {
 		options: Omit<FindManyOptions, "where"> & { where?: { locale?: string } } = {},
 	): Promise<FindManyResult<ContentItem & { deletedAt: string }>> {
 		const tableName = getTableName(type);
-		const limit = Math.min(options.limit || 50, 100);
+		const limit = Math.max(1, Math.min(options.limit || 50, 100));
 
 		// Determine ordering - default to most recently deleted
 		const orderField = options.orderBy?.field || "deletedAt";
@@ -2195,13 +2217,26 @@ export class ContentRepository {
 		return result.rows.map((row) => this.mapRow(type, row));
 	}
 
-	/** Whether any row of `translationGroup` exists, trashed rows included. */
-	async hasTranslationsIncludingTrashed(type: string, translationGroup: string): Promise<boolean> {
+	/**
+	 * Whether any row still shares `translationGroup`, trashed rows included.
+	 * Group-keyed satellite data (term assignments, reference edges) is owned by
+	 * the group, not by a single locale row, so a purge may only cascade to it
+	 * once nothing is left to own it — and a trashed sibling is still restorable.
+	 */
+	async hasTranslationsIncludingTrashed(
+		type: string,
+		translationGroup: string,
+		options: { excludeId?: string } = {},
+	): Promise<boolean> {
 		const tableName = getTableName(type);
+		// Asked before a row is deleted, "does anything else hold this group?"
+		// has to leave that row out of the answer.
+		const exclusion = options.excludeId ? sql`AND id != ${options.excludeId}` : sql``;
 
 		const result = await sql<Record<string, unknown>>`
 			SELECT id FROM ${sql.ref(tableName)}
 			WHERE translation_group = ${translationGroup}
+			${exclusion}
 			LIMIT 1
 		`.execute(this.db);
 
@@ -2970,9 +3005,16 @@ export class ContentRepository {
 			.where("collection.slug", "=", type)
 			.where("field.slug", "in", fields)
 			.where("field.indexed", "=", 1)
-			.select(["field.slug", "field.type"])
+			.select(["field.slug", "field.type", "field.validation"])
 			.execute();
-		const metadata = new Map(rows.map((row) => [row.slug, row.type as FieldType]));
+		// `indexed` alone is not enough: a storage-less field has no column to
+		// filter on. A reference field bound to a relation after it was indexed can
+		// still carry the flag, and its column no longer receives writes.
+		const metadata = new Map(
+			rows
+				.filter((row) => !isStoragelessFieldRow(row))
+				.map((row) => [row.slug, row.type as FieldType]),
+		);
 
 		if (metadata.size === 0 && !(await this.collectionExists(type))) return [];
 

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

@@ -345,7 +345,7 @@ export class PluginStorageRepository<T = unknown> implements StorageCollection<T
 	 */
 	async query(options: QueryOptions = {}): Promise<PaginatedResult<{ id: string; data: T }>> {
 		const { where = {}, orderBy = {}, cursor } = options;
-		const limit = Math.min(options.limit ?? 50, 100);
+		const limit = Math.max(1, Math.min(options.limit ?? 50, 100));
 
 		// Validate that all queried fields are indexed
 		validateWhereClause(where, this.indexedFields, this.pluginId, this.collection);

package/src/database/repositories/redirect.ts

@@ -2,11 +2,13 @@ import { sql, type Kysely } from "kysely";
 import { ulid } from "ulidx";
 
 import { interpolateUrlPattern } from "../../i18n/resolve.js";
+import { isSiteRelativeDestination } from "../../redirects/destination.js";
 import {
 	compilePattern,
 	matchPattern,
 	interpolateDestination,
 	isPattern,
+	validatePattern,
 } from "../../redirects/patterns.js";
 import { currentTimestampValue, isPostgres } from "../dialect-helpers.js";
 import type { Database, RedirectTable } from "../types.js";
@@ -468,18 +470,21 @@ export class RedirectRepository {
 	async matchPath(path: string): Promise<RedirectMatch | null> {
 		// 1. Exact match (fast, indexed)
 		const exact = await this.findExactMatch(path);
-		if (exact) {
+		if (exact && isSiteRelativeDestination(exact.destination)) {
 			return { redirect: exact, resolvedDestination: exact.destination };
 		}
 
 		// 2. Pattern match
 		const patterns = await this.findEnabledPatternRules();
 		for (const redirect of patterns) {
+			if (validatePattern(redirect.source)) continue;
 			const compiled = compilePattern(redirect.source);
 			const params = matchPattern(compiled, path);
 			if (params) {
 				const resolved = interpolateDestination(redirect.destination, params);
-				return { redirect, resolvedDestination: resolved };
+				if (isSiteRelativeDestination(resolved)) {
+					return { redirect, resolvedDestination: resolved };
+				}
 			}
 		}