emdash 0.12.0 → 0.14.0

package/src/astro/routes/api/import/wordpress/execute.ts

@@ -20,6 +20,14 @@ import { requirePerm } from "#api/authorize.js";
 import { apiError, apiSuccess, handleError } from "#api/error.js";
 import { BylineRepository } from "#db/repositories/byline.js";
 import { resolveImportByline } from "#import/utils.js";
+import {
+	attachPostTaxonomies,
+	isWxrTaxonomyConflictError,
+	mirrorTermsToLocales,
+	preImportWxrTaxonomies,
+	setPostTermAssignmentsReplacing,
+	type TaxonomyImportPlan,
+} from "#import/wxr-taxonomies.js";
 import type { EmDashHandlers, EmDashManifest } from "#types";
 import { slugify } from "#utils/slugify.js";
 
@@ -57,6 +65,21 @@ export interface ImportResult {
 		created: number;
 		skipped: number;
 	};
+	/** Taxonomy import results (categories, tags, custom taxonomies). */
+	taxonomies?: {
+		/** Terms newly created during this import, keyed by taxonomy name. */
+		termsCreated: Record<string, number>;
+		/** Existing terms that were re-used, keyed by taxonomy name. */
+		termsReused: Record<string, number>;
+		/** Total pivot rows (post <-> term) written to `content_taxonomies`. */
+		assignments: number;
+		/**
+		 * Custom taxonomy names from the WXR file that had no matching EmDash
+		 * definition and were therefore skipped. Lets the admin UI surface a
+		 * "create taxonomy X first" hint without re-running the import.
+		 */
+		missingTaxonomies: string[];
+	};
 }
 
 export const POST: APIRoute = async ({ request, locals }) => {
@@ -107,6 +130,49 @@ export const POST: APIRoute = async ({ request, locals }) => {
 			authorDisplayNames.set(author.login, author.displayName || author.login);
 		}
 
+		// Pre-create taxonomy terms (categories, tags, custom taxonomies) so
+		// per-post assignments can resolve to existing rows. Done before any
+		// content insert because WXR exports list terms at the top of the
+		// file but per-item assignments only reference them by slug.
+		const taxonomyPlan = await preImportWxrTaxonomies(
+			emdash.db,
+			wxr.posts,
+			wxr.categories,
+			wxr.tags,
+			wxr.terms,
+			config.locale,
+		);
+
+		// Multilingual imports (WPML / Polylang -- see #1080) need a term
+		// row at each per-post locale, all sharing the canonical term's
+		// `translation_group`. Without this, `getTermsForEntry(..., locale)`
+		// on non-canonical translations comes back empty.
+		//
+		// The mirror raises `WxrTaxonomyConflictError` with an operator-
+		// actionable message when an existing locale row has an
+		// incompatible group. Surface its `publicMessage` directly so the
+		// admin UI can tell the user which (taxonomy, slug, locale) needs
+		// reconciliation. Other errors (DB connectivity, unexpected
+		// repository failures) re-throw to the outer catch where
+		// `handleError` masks them with the generic "Failed to import
+		// content" -- exposing raw DB errors to clients would leak schema
+		// names and bypass the AGENTS.md "never expose error.message" rule.
+		const postLocales = new Set<string>();
+		for (const post of wxr.posts) {
+			if (post.locale) postLocales.add(post.locale);
+		}
+		if (postLocales.size > 0) {
+			try {
+				await mirrorTermsToLocales(emdash.db, taxonomyPlan, postLocales, config.locale);
+			} catch (mirrorError) {
+				if (isWxrTaxonomyConflictError(mirrorError)) {
+					console.error("[WXR_IMPORT_TAXONOMY_CONFLICT]", mirrorError);
+					return apiError("WXR_IMPORT_TAXONOMY_CONFLICT", mirrorError.publicMessage, 409);
+				}
+				throw mirrorError;
+			}
+		}
+
 		// Import content (locale from config scopes all items)
 		const result = await importContent(
 			wxr.posts,
@@ -116,6 +182,7 @@ export const POST: APIRoute = async ({ request, locals }) => {
 			attachmentMap,
 			config.locale,
 			authorDisplayNames,
+			taxonomyPlan,
 		);
 
 		// Import reusable blocks as sections (if enabled)
@@ -138,14 +205,15 @@ export const POST: APIRoute = async ({ request, locals }) => {
 	}
 };
 
-async function importContent(
+export async function importContent(
 	posts: WxrPost[],
 	config: ImportConfig,
 	emdash: EmDashHandlers,
 	manifest: EmDashManifest,
 	attachmentMap: Map<string, string>,
-	locale?: string,
-	authorDisplayNames?: Map<string, string>,
+	locale: string | undefined,
+	authorDisplayNames: Map<string, string> | undefined,
+	taxonomyPlan: TaxonomyImportPlan,
 ): Promise<ImportResult> {
 	const result: ImportResult = {
 		success: true,
@@ -153,6 +221,12 @@ async function importContent(
 		skipped: 0,
 		errors: [],
 		byCollection: {},
+		taxonomies: {
+			termsCreated: taxonomyPlan.termsCreated,
+			termsReused: taxonomyPlan.termsReused,
+			assignments: 0,
+			missingTaxonomies: taxonomyPlan.missingTaxonomies,
+		},
 	};
 
 	// Create content repository for checking existing items
@@ -160,6 +234,11 @@ async function importContent(
 	const bylineRepo = new BylineRepository(emdash.db);
 	const bylineCache = new Map<string, string>();
 
+	// Source-side translation group ID -> the EmDash ID of the first post we
+	// imported for that group. Subsequent translations are linked via
+	// `translationOf` so they share a `translation_group` on the EmDash side.
+	const translationGroupMap = new Map<string, string>();
+
 	for (const post of posts) {
 		const postType = post.postType || "post";
 		const mapping = config.postTypeMappings[postType];
@@ -190,15 +269,45 @@ async function importContent(
 			// Generate slug from post name or title
 			const slug = post.postName || slugify(post.title || `post-${post.id || Date.now()}`);
 
-			// Check if already exists (idempotency)
+			// Per-post locale: prefer the value extracted from WPML/Polylang
+			// metadata; fall back to the upload-wide locale. Two translations
+			// sharing `post_name` (e.g. /en/hello + /ar/hello) collide on the
+			// `UNIQUE(slug, locale)` constraint when they share a locale, so
+			// honouring the per-post value is what makes multilingual imports
+			// land correctly. See issue #1080.
+			const postLocale = post.locale ?? locale;
+
+			// Check if already exists (idempotency). Match against the
+			// per-post locale so the same slug in different locales doesn't
+			// false-positive as duplicate.
 			if (config.skipExisting) {
-				const existing = await contentRepo.findBySlug(collection, slug);
+				const existing = await contentRepo.findBySlug(collection, slug, postLocale);
 				if (existing) {
+					// Record the translation group mapping so later
+					// translations in this WXR can link to the existing
+					// item. We deliberately trust the WXR's grouping over
+					// the existing row's `translation_group`: a singleton
+					// existing row gets folded into the WXR's group when
+					// `handleContentCreate` resolves the new translation's
+					// `translationOf`. Pre-existing translations that
+					// already belong to a different group are left alone --
+					// the user is responsible for reconciling those through
+					// the admin if they don't match the WXR.
+					if (post.translationGroup) {
+						translationGroupMap.set(post.translationGroup, existing.id);
+					}
 					result.skipped++;
 					continue;
 				}
 			}
 
+			// Resolve translation group: if this post belongs to a group and
+			// we've already imported one of its translations, link to it.
+			let translationOf: string | undefined;
+			if (post.translationGroup) {
+				translationOf = translationGroupMap.get(post.translationGroup);
+			}
+
 			// Map WordPress status to EmDash status
 			const status = mapStatus(post.status);
 
@@ -252,7 +361,8 @@ async function importContent(
 				status,
 				authorId,
 				bylines: bylineId ? [{ bylineId }] : undefined,
-				locale,
+				locale: postLocale,
+				translationOf,
 				createdAt,
 				publishedAt,
 			});
@@ -260,6 +370,75 @@ async function importContent(
 			if (createResult.success) {
 				result.imported++;
 				result.byCollection[collection] = (result.byCollection[collection] || 0) + 1;
+
+				// `handleContentCreate` returns `data: { item, _rev? }` on
+				// success (see `ApiResult<ContentResponse>` in
+				// `api/handlers/content.ts`). `HandlerResponse.data` is
+				// typed as `unknown` to avoid coupling the route surface to
+				// internal handler types, so we narrow here.
+				// eslint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- handler contract documented at handleContentCreate
+				const createdItem = (createResult.data as { item: { id: string } } | undefined)?.item;
+
+				// Track translation group: the first imported post in a group
+				// becomes the anchor that later translations link to.
+				if (
+					createdItem &&
+					post.translationGroup &&
+					!translationGroupMap.has(post.translationGroup)
+				) {
+					translationGroupMap.set(post.translationGroup, createdItem.id);
+				}
+
+				// Attach taxonomy assignments parsed from the WXR's per-item
+				// <category> elements.
+				//
+				// Anchors (no `translationOf`) get an additive attach -- the
+				// row is fresh, no inherited pivots to consider.
+				//
+				// Translations get per-taxonomy replace semantics. WPML's
+				// "Translate Independently" mode is per-taxonomy, not per-
+				// post: a translation that overrides `category` shouldn't
+				// lose its inherited `tag` or `genre`. The replace path
+				// only touches taxonomies the translation actually carries
+				// AND that resolve to at least one term that survives the
+				// def's `collections` filter; taxonomies with no resolved
+				// terms (missing-def, dropped by filter, or just absent
+				// from the WXR) fall through with the inherited set intact
+				// from `copyEntryTerms`.
+				if (createdItem) {
+					try {
+						const written = translationOf
+							? await setPostTermAssignmentsReplacing(
+									emdash.db,
+									collection,
+									createdItem.id,
+									post,
+									taxonomyPlan,
+								)
+							: await attachPostTaxonomies(
+									emdash.db,
+									collection,
+									createdItem.id,
+									post,
+									taxonomyPlan,
+								);
+						if (result.taxonomies) {
+							result.taxonomies.assignments += written;
+						}
+					} catch (taxError) {
+						console.error(
+							`Failed to attach taxonomies for "${post.title || "Untitled"}":`,
+							taxError,
+						);
+						result.errors.push({
+							title: post.title || "Untitled",
+							error:
+								taxError instanceof Error && taxError.message
+									? `Imported but failed to attach taxonomies: ${taxError.message}`
+									: "Imported but failed to attach taxonomies",
+						});
+					}
+				}
 			} else {
 				result.errors.push({
 					title: post.title || "Untitled",

package/src/astro/routes/api/menus/[name]/items/[id].ts

@@ -0,0 +1,69 @@
+/**
+ * Single menu item endpoint
+ *
+ * PUT    /_emdash/api/menus/:name/items/:id[?locale=xx]
+ * DELETE /_emdash/api/menus/:name/items/:id[?locale=xx]
+ */
+
+import type { APIRoute } from "astro";
+
+import { requirePerm } from "#api/authorize.js";
+import { apiError, handleError, unwrapResult } from "#api/error.js";
+import { handleMenuItemDelete, handleMenuItemUpdate } from "#api/handlers/menus.js";
+import { isParseError, parseBody, parseQuery } from "#api/parse.js";
+import { localeFilterQuery, updateMenuItemBody } from "#api/schemas.js";
+
+export const prerender = false;
+
+export const PUT: APIRoute = async ({ params, request, locals }) => {
+	const { emdash, user } = locals;
+	const name = params.name!;
+	const itemId = params.id;
+
+	const denied = requirePerm(user, "menus:manage");
+	if (denied) return denied;
+
+	if (!itemId) {
+		return apiError("VALIDATION_ERROR", "id is required", 400);
+	}
+
+	const localeQ = parseQuery(new URL(request.url), localeFilterQuery);
+	if (isParseError(localeQ)) return localeQ;
+
+	try {
+		const body = await parseBody(request, updateMenuItemBody);
+		if (isParseError(body)) return body;
+
+		const result = await handleMenuItemUpdate(emdash.db, name, itemId, body, {
+			locale: localeQ.locale,
+		});
+		return unwrapResult(result);
+	} catch (error) {
+		return handleError(error, "Failed to update menu item", "MENU_ITEM_UPDATE_ERROR");
+	}
+};
+
+export const DELETE: APIRoute = async ({ params, request, locals }) => {
+	const { emdash, user } = locals;
+	const name = params.name!;
+	const itemId = params.id;
+
+	const denied = requirePerm(user, "menus:manage");
+	if (denied) return denied;
+
+	if (!itemId) {
+		return apiError("VALIDATION_ERROR", "id is required", 400);
+	}
+
+	const localeQ = parseQuery(new URL(request.url), localeFilterQuery);
+	if (isParseError(localeQ)) return localeQ;
+
+	try {
+		const result = await handleMenuItemDelete(emdash.db, name, itemId, {
+			locale: localeQ.locale,
+		});
+		return unwrapResult(result);
+	} catch (error) {
+		return handleError(error, "Failed to delete menu item", "MENU_ITEM_DELETE_ERROR");
+	}
+};

package/src/astro/routes/api/menus/[name]/items.ts

@@ -1,28 +1,16 @@
 /**
- * Menu items CRUD endpoints
+ * Menu items create endpoint
  *
- * POST   /_emdash/api/menus/:name/items[?locale=xx]
- * PUT    /_emdash/api/menus/:name/items?id=...[&locale=xx]
- * DELETE /_emdash/api/menus/:name/items?id=...[&locale=xx]
+ * POST /_emdash/api/menus/:name/items[?locale=xx] - Create a new menu item
  */
 
 import type { APIRoute } from "astro";
 
 import { requirePerm } from "#api/authorize.js";
 import { handleError, unwrapResult } from "#api/error.js";
-import {
-	handleMenuItemCreate,
-	handleMenuItemDelete,
-	handleMenuItemUpdate,
-} from "#api/handlers/menus.js";
+import { handleMenuItemCreate } from "#api/handlers/menus.js";
 import { isParseError, parseBody, parseQuery } from "#api/parse.js";
-import {
-	createMenuItemBody,
-	localeFilterQuery,
-	menuItemDeleteQuery,
-	menuItemUpdateQuery,
-	updateMenuItemBody,
-} from "#api/schemas.js";
+import { createMenuItemBody, localeFilterQuery } from "#api/schemas.js";
 
 export const prerender = false;
 
@@ -46,52 +34,3 @@ export const POST: APIRoute = async ({ params, request, locals }) => {
 		return handleError(error, "Failed to create menu item", "MENU_ITEM_CREATE_ERROR");
 	}
 };
-
-export const PUT: APIRoute = async ({ params, request, locals }) => {
-	const { emdash, user } = locals;
-	const name = params.name!;
-
-	const denied = requirePerm(user, "menus:manage");
-	if (denied) return denied;
-
-	const url = new URL(request.url);
-	const query = parseQuery(url, menuItemUpdateQuery);
-	if (isParseError(query)) return query;
-	const localeQ = parseQuery(url, localeFilterQuery);
-	if (isParseError(localeQ)) return localeQ;
-	const itemId = query.id;
-
-	try {
-		const body = await parseBody(request, updateMenuItemBody);
-		if (isParseError(body)) return body;
-
-		const result = await handleMenuItemUpdate(emdash.db, name, itemId, body, {
-			locale: localeQ.locale,
-		});
-		return unwrapResult(result);
-	} catch (error) {
-		return handleError(error, "Failed to update menu item", "MENU_ITEM_UPDATE_ERROR");
-	}
-};
-
-export const DELETE: APIRoute = async ({ params, request, locals }) => {
-	const { emdash, user } = locals;
-	const name = params.name!;
-
-	const denied = requirePerm(user, "menus:manage");
-	if (denied) return denied;
-
-	const url = new URL(request.url);
-	const query = parseQuery(url, menuItemDeleteQuery);
-	if (isParseError(query)) return query;
-	const localeQ = parseQuery(url, localeFilterQuery);
-	if (isParseError(localeQ)) return localeQ;
-	const itemId = query.id;
-
-	try {
-		const result = await handleMenuItemDelete(emdash.db, name, itemId, { locale: localeQ.locale });
-		return unwrapResult(result);
-	} catch (error) {
-		return handleError(error, "Failed to delete menu item", "MENU_ITEM_DELETE_ERROR");
-	}
-};

package/src/astro/types.ts

@@ -144,8 +144,43 @@ export interface EmDashManifest {
 	/**
 	 * Whether the plugin marketplace is configured.
 	 * When true, the admin UI can show marketplace browse/install features.
+	 *
+	 * When `registry` is also present, the registry replaces the marketplace
+	 * for the admin UI's browse and install flows. Existing marketplace-installed
+	 * plugins continue to work; new installs and updates use the registry.
 	 */
 	marketplace?: boolean;
+	/**
+	 * Decentralized plugin registry configuration.
+	 *
+	 * When present, the admin UI uses the registry instead of the
+	 * centralized marketplace for browse and install. The aggregator URL
+	 * and policy fields are read by the browser; the `acceptLabelers`
+	 * header value is forwarded with every aggregator request.
+	 *
+	 * See the `registry` integration option in `astro.config.mjs`.
+	 */
+	registry?: {
+		aggregatorUrl: string;
+		acceptLabelers?: string;
+		policy?: {
+			/**
+			 * Minimum release age in seconds. The admin UI's
+			 * latest-release selection filter holds back releases younger
+			 * than this when computing the recommended install/update.
+			 *
+			 * Normalized from the integration option's duration string
+			 * (`"48h"`) to seconds at manifest build time so the browser
+			 * doesn't need a duration parser.
+			 */
+			minimumReleaseAgeSeconds?: number;
+			/**
+			 * Publishers / packages exempt from {@link minimumReleaseAgeSeconds}.
+			 * See `RegistryConfig.policy.minimumReleaseAgeExclude`.
+			 */
+			minimumReleaseAgeExclude?: string[];
+		};
+	};
 	/**
 	 * Admin branding overrides for white-labeling.
 	 * Set via the `admin` config in `astro.config.mjs`.
@@ -395,6 +430,9 @@ export interface EmDashHandlers {
 	// Sync marketplace plugin states (after install/update/uninstall)
 	syncMarketplacePlugins: () => Promise<void>;
 
+	// Sync registry plugin states (after install/update/uninstall)
+	syncRegistryPlugins: () => Promise<void>;
+
 	// Update plugin enabled/disabled status and rebuild hook pipeline
 	setPluginStatus: (pluginId: string, status: "active" | "inactive") => Promise<void>;