emdash 0.32.0 → 0.34.0

package/src/fields/file.ts

@@ -12,10 +12,13 @@ export interface FileOptions {
 export function file(options: FileOptions = {}): FieldDefinition<FileValue> {
 	const fileObjSchema = z.object({
 		id: z.string(),
-		url: z.string(),
-		filename: z.string(),
-		mimeType: z.string(),
-		size: z.number(),
+		url: z.string().optional(),
+		src: z.string().optional(),
+		filename: z.string().optional(),
+		mimeType: z.string().optional(),
+		size: z.number().optional(),
+		provider: z.string().optional(),
+		meta: z.record(z.string(), z.unknown()).optional(),
 	});
 
 	const schema: z.ZodTypeAny = options.required ? fileObjSchema : fileObjSchema.optional();

package/src/fields/image.ts

@@ -4,10 +4,17 @@ import type { FieldDefinition, ImageValue } from "./types.js";
 
 const imageSchema = z.object({
 	id: z.string(),
-	src: z.string(),
+	src: z.string().optional(),
 	alt: z.string().optional(),
 	width: z.number().optional(),
 	height: z.number().optional(),
+	filename: z.string().optional(),
+	mimeType: z.string().optional(),
+	blurhash: z.string().optional(),
+	dominantColor: z.string().optional(),
+	provider: z.string().optional(),
+	previewUrl: z.string().optional(),
+	meta: z.record(z.string(), z.unknown()).optional(),
 });
 
 export interface ImageOptions {

package/src/fields/types.ts

@@ -56,12 +56,25 @@ import type { MediaValue } from "../media/types.js";
 export type ImageValue = MediaValue;
 
 /**
- * File field value
+ * Persisted file field value.
+ *
+ * File values are references with cached metadata, not implicitly hydrated
+ * media records. Use the media provider API when current metadata is needed.
  */
 export interface FileValue {
 	id: string;
-	url: string;
-	filename: string;
-	mimeType: string;
-	size: number;
+	/** Legacy cached URL. Provider-backed values commonly omit this. */
+	url?: string;
+	/** Direct URL used by external media providers. */
+	src?: string;
+	/** Cached original filename, when available. */
+	filename?: string;
+	/** Cached MIME type, when available. */
+	mimeType?: string;
+	/** Cached file size in bytes, when persisted with the value. */
+	size?: number;
+	/** Media provider ID. Defaults to `local` when omitted. */
+	provider?: string;
+	/** Provider-specific data needed to resolve or render the file. */
+	meta?: Record<string, unknown>;
 }

package/src/i18n/config.ts

@@ -12,6 +12,8 @@ export interface I18nConfig {
 	prefixDefaultLocale?: boolean;
 }
 
+export const LOCALE_CODE_PATTERN = /^[a-z]{2,3}(-[a-z0-9]{2,8})*$/i;
+
 const I18N_CONFIG_KEY = Symbol.for("emdash:i18n-config");
 
 function configStore(): Record<symbol, I18nConfig | null | undefined> {
@@ -43,6 +45,36 @@ export function resolveConfiguredLocale(locale: string): string {
 	);
 }
 
+/** Whether a string matches the locale-code subset accepted by EmDash. */
+export function isValidLocaleCode(locale: string): boolean {
+	return LOCALE_CODE_PATTERN.test(locale);
+}
+
+/** Resolve the locale for a new content row. */
+export function resolveContentCreateLocale(
+	locale: unknown,
+	config: I18nConfig | null = getI18nConfig(),
+): string {
+	if (locale !== undefined) {
+		if (typeof locale !== "string") {
+			throw new Error("Invalid locale code: expected a string");
+		}
+		if (!isValidLocaleCode(locale)) {
+			throw new Error(`Invalid locale code: "${locale}"`);
+		}
+
+		const configured = config?.locales.find(
+			(candidate) => candidate.toLowerCase() === locale.toLowerCase(),
+		);
+		if (config && !configured) {
+			throw new Error(`Locale "${locale}" is not configured for this site`);
+		}
+		return configured ?? locale;
+	}
+
+	return config?.defaultLocale ?? "en";
+}
+
 /**
  * Check if i18n is enabled.
  * Returns true when multiple locales are configured.

package/src/i18n/repair-locale-casing.ts

@@ -13,7 +13,6 @@ export async function repairLocaleCasing(
 
 	for (const tableName of tableNames) {
 		const table = sql.ref(tableName);
-		const slug = tableName.slice("ec_".length);
 		for (const locale of configuredLocales) {
 			await sql`
 				UPDATE ${table} AS target
@@ -33,19 +32,6 @@ export async function repairLocaleCasing(
 							AND candidate.locale != ${locale}
 					)
 			`.execute(db);
-
-			await sql`
-				UPDATE content_taxonomies AS pivot
-				SET locale = ${locale}
-				WHERE pivot.collection = ${slug}
-					AND lower(pivot.locale) = lower(${locale})
-					AND pivot.locale != ${locale}
-					AND EXISTS (
-						SELECT 1
-						FROM ${table} AS content
-						WHERE content.id = pivot.entry_id AND content.locale = ${locale}
-					)
-			`.execute(db);
 		}
 	}
 }

package/src/i18n/taxonomy-locale-diagnostic.ts

@@ -0,0 +1,47 @@
+import type { Kysely } from "kysely";
+
+import type { Database } from "../database/types.js";
+
+const REPAIR_GUIDE =
+	"https://docs.emdashcms.com/guides/internationalization/#repairing-taxonomy-locale-mismatches";
+
+interface TaxonomyLocaleMismatch {
+	source: "definitions" | "terms";
+	locale: string;
+}
+
+export async function warnAboutUnconfiguredTaxonomyLocales(
+	db: Kysely<Database>,
+	configuredLocales: readonly string[],
+	definitionLocales?: readonly string[],
+): Promise<void> {
+	const supportedLocales = configuredLocales.length > 0 ? configuredLocales : ["en"];
+	const definitionRows =
+		definitionLocales === undefined
+			? await db
+					.selectFrom("_emdash_taxonomy_defs")
+					.select("locale")
+					.distinct()
+					.where("locale", "not in", supportedLocales)
+					.execute()
+			: [...new Set(definitionLocales)]
+					.filter((locale) => !supportedLocales.includes(locale))
+					.map((locale) => ({ locale }));
+	const termRows = await db
+		.selectFrom("taxonomies")
+		.select("locale")
+		.distinct()
+		.where("locale", "not in", supportedLocales)
+		.execute();
+	const mismatches: TaxonomyLocaleMismatch[] = [
+		...definitionRows.map(({ locale }) => ({ source: "definitions" as const, locale })),
+		...termRows.map(({ locale }) => ({ source: "terms" as const, locale })),
+	].toSorted((a, b) => a.source.localeCompare(b.source) || a.locale.localeCompare(b.locale));
+	if (mismatches.length === 0) return;
+
+	const details = mismatches.map(({ source, locale }) => `${source}: ${locale}`).join("; ");
+	console.warn(
+		`EmDash: Taxonomy rows use locales outside the configured locales (${supportedLocales.join(", ")}): ${details}. ` +
+			`Locale-scoped reads may not return these rows. Review and repair them explicitly: ${REPAIR_GUIDE}`,
+	);
+}

package/src/import/wxr-taxonomies.ts

@@ -549,26 +549,21 @@ export async function attachPostTaxonomies(
 ): Promise<number> {
 	const repo = new TaxonomyRepository(db);
 	const resolved = resolvePostTermAssignments(collection, post, plan);
-
-	let attached = 0;
+	const groups = new Set<string>();
 	for (const [, termIds] of resolved) {
 		for (const termId of termIds) {
-			const wrote = await attachToEntryCountingInserts(db, repo, plan, collection, entryId, termId);
-			if (wrote) attached++;
+			const group = await termTranslationGroup(repo, plan, termId);
+			if (group) groups.add(group);
 		}
 	}
-	return attached;
+	return repo.attachGroupsToEntry(collection, entryId, [...groups]);
 }
 
 /**
  * Replace assignments per-taxonomy from a parsed WXR post. Used for
- * translations: WPML's "Translate Independently" mode lets translators
- * override term assignments per-taxonomy, not per-post. A translation that
- * overrides `category` shouldn't lose its inherited `tag` or `genre`. We
- * only call `setTermsForEntry(name, ids)` for taxonomies where the
- * translation actually resolved at least one term -- taxonomies with no
- * resolvable+permitted terms are left alone so inherited rows from
- * `copyEntryTerms` stay intact.
+ * translations. Assignments belong to the content translation_group, so a
+ * translated item's explicit taxonomy replaces that taxonomy for every
+ * locale. Taxonomies with no resolvable permitted terms are left unchanged.
  *
  * Returns the number of pivot rows after replacement (sum of `termIds`
  * lists across taxonomies actually touched). Note this counts logical
@@ -612,41 +607,6 @@ async function termTranslationGroup(
 	return group;
 }
 
-/**
- * Wrapper around `TaxonomyRepository.attachToEntry` that returns whether
- * an actual row was inserted (vs. silently skipped by the `ON CONFLICT DO
- * NOTHING` branch). Lets the importer's `assignments` counter reflect real
- * writes rather than re-import no-ops.
- *
- * Best-effort: we check pivot existence first, then call `attachToEntry`.
- * A concurrent insert between the check and the attach would make us
- * report `false` while a row was in fact inserted -- the count is for
- * summary display only, never correctness.
- */
-async function attachToEntryCountingInserts(
-	db: Kysely<Database>,
-	repo: TaxonomyRepository,
-	plan: TaxonomyImportPlan,
-	collection: string,
-	entryId: string,
-	termId: string,
-): Promise<boolean> {
-	const group = await termTranslationGroup(repo, plan, termId);
-	if (!group) return false;
-
-	const existing = await db
-		.selectFrom("content_taxonomies")
-		.select("collection")
-		.where("collection", "=", collection)
-		.where("entry_id", "=", entryId)
-		.where("taxonomy_id", "=", group)
-		.executeTakeFirst();
-	if (existing) return false;
-
-	await repo.attachToEntry(collection, entryId, termId);
-	return true;
-}
-
 /**
  * Mirror every term in the plan into each additional locale used by the
  * incoming posts. New rows share the canonical term's `translation_group`

package/src/index.ts

@@ -27,6 +27,13 @@ export type {
 	FindManyOptions,
 	FindManyResult,
 } from "./database/repositories/index.js";
+export type {
+	ContentFieldFilterScalar,
+	ContentFieldFilterValue,
+	ContentFieldFilters,
+	ContentFieldInFilter,
+	ContentFieldRangeFilter,
+} from "./content-list-query.js";
 export type { MediaItem, CreateMediaInput } from "./database/repositories/media.js";
 export type { CompoundSelectLimitedAdapter } from "./database/dialect-helpers.js";
 
@@ -109,7 +116,7 @@ export type {
 export { ulid } from "ulidx";
 export { computeContentHash, hashString } from "./utils/hash.js";
 export { sanitizeHref, isSafeHref } from "./utils/url.js";
-export { decodeSlug } from "./utils/slugify.js";
+export { decodeSlug, slugify } from "./utils/slugify.js";
 
 // Live Collections query functions (loader is in emdash/runtime)
 export {
@@ -144,7 +151,12 @@ export { after } from "./after.js";
 export type { WaitUntilFn } from "./after.js";
 
 // i18n configuration (from Astro config)
-export { getI18nConfig, isI18nEnabled, getFallbackChain } from "./i18n/config.js";
+export {
+	getI18nConfig,
+	isI18nEnabled,
+	getFallbackChain,
+	resolveContentCreateLocale,
+} from "./i18n/config.js";
 export type { I18nConfig } from "./i18n/config.js";
 
 // Visual editing
@@ -231,6 +243,10 @@ export {
 	NoopSandboxRunner,
 	SandboxNotAvailableError,
 	SandboxUnavailableError,
+	createSandboxRouteError,
+	createSandboxRouteErrorEnvelope,
+	getSandboxRouteErrorDetails,
+	getSandboxRouteErrorEnvelope,
 	createNoopSandboxRunner,
 	// HTTP access for plugins (shared between in-process, Cloudflare, and workerd runners)
 	createHttpAccess,
@@ -245,6 +261,7 @@ export type {
 	StorageCollection,
 	KVAccess,
 	ContentAccess,
+	ContentCreateOptions,
 	MediaAccess,
 	HttpAccess,
 	LogAccess,
@@ -300,6 +317,9 @@ export type {
 	PluginManifest,
 	ValidatedPluginManifest,
 	SerializedRequest,
+	SandboxRouteErrorCode,
+	SandboxRouteErrorDetails,
+	SandboxRouteErrorEnvelope,
 } from "./plugins/index.js";
 
 // Capability normalization (legacy → canonical alias layer)
@@ -510,6 +530,7 @@ export type {
 
 // Search
 export {
+	SEARCH_TOKENIZERS,
 	FTSManager,
 	search,
 	searchWithDb,
@@ -521,6 +542,7 @@ export {
 } from "./search/index.js";
 export type {
 	SearchConfig,
+	SearchTokenizer,
 	SearchOptions,
 	CollectionSearchOptions,
 	SearchResult,
@@ -548,4 +570,7 @@ export type {
 	SqliteConfig,
 	LibsqlConfig,
 	PostgresConfig,
+	CollectionDeletionGuardInput,
+	CollectionDeletionGuardResult,
+	ExecuteCollectionDeletionGuard,
 } from "./db/adapters.js";