emdash 0.0.0-b → 0.0.1

package/src/fields/types.ts

@@ -0,0 +1,64 @@
+import type { z } from "astro/zod";
+
+/**
+ * SQLite column types that map from field types
+ */
+export type ColumnType = "TEXT" | "REAL" | "INTEGER" | "JSON";
+
+/**
+ * Base field definition
+ *
+ * Note: schema uses z.ZodTypeAny to accommodate optional/default wrappers
+ */
+export interface FieldDefinition<_T = unknown> {
+	type: string;
+	/**
+	 * The SQLite column type to use when storing this field
+	 */
+	columnType: ColumnType;
+	schema: z.ZodTypeAny;
+	options?: unknown;
+	ui?: FieldUIHints;
+}
+
+/**
+ * UI hints for admin rendering
+ */
+export interface FieldUIHints {
+	widget?: string;
+	placeholder?: string;
+	helpText?: string;
+	rows?: number; // For textarea
+	min?: number | string;
+	max?: number | string;
+	[key: string]: unknown;
+}
+
+/**
+ * Portable Text block structure
+ */
+export interface PortableTextBlock {
+	_type: string;
+	_key: string;
+	[key: string]: unknown;
+}
+
+// Re-export MediaValue from media/types.ts (canonical location)
+export type { MediaValue } from "../media/types.js";
+import type { MediaValue } from "../media/types.js";
+
+/**
+ * @deprecated Use MediaValue instead. ImageValue is an alias for backwards compatibility.
+ */
+export type ImageValue = MediaValue;
+
+/**
+ * File field value
+ */
+export interface FileValue {
+	id: string;
+	url: string;
+	filename: string;
+	mimeType: string;
+	size: number;
+}

package/src/i18n/config.ts

@@ -0,0 +1,68 @@
+/**
+ * EmDash i18n Configuration
+ *
+ * Reads locale configuration from the virtual module (sourced from Astro config).
+ * Initialized during runtime startup, then available via getI18nConfig().
+ */
+
+export interface I18nConfig {
+	defaultLocale: string;
+	locales: string[];
+	fallback?: Record<string, string>;
+	prefixDefaultLocale?: boolean;
+}
+
+let _config: I18nConfig | null | undefined;
+
+/**
+ * Initialize i18n config from virtual module data.
+ * Called during runtime initialization.
+ */
+export function setI18nConfig(config: I18nConfig | null): void {
+	_config = config;
+}
+
+/**
+ * Get the current i18n config.
+ * Returns null if i18n is not configured.
+ */
+export function getI18nConfig(): I18nConfig | null {
+	return _config ?? null;
+}
+
+/**
+ * Check if i18n is enabled.
+ * Returns true when multiple locales are configured.
+ */
+export function isI18nEnabled(): boolean {
+	return _config != null && _config.locales.length > 1;
+}
+
+/**
+ * Resolve fallback locale chain for a given locale.
+ * Returns array of locales to try, from most preferred to least.
+ * Always ends with defaultLocale.
+ */
+export function getFallbackChain(locale: string): string[] {
+	if (!_config) return [locale];
+
+	const chain: string[] = [locale];
+	let current = locale;
+	const visited = new Set<string>([locale]);
+
+	while (_config.fallback?.[current]) {
+		// eslint-disable-next-line typescript-eslint(no-unnecessary-type-assertion) -- noUncheckedIndexedAccess
+		const next = _config.fallback[current]!;
+		if (visited.has(next)) break; // prevent cycles
+		chain.push(next);
+		visited.add(next);
+		current = next;
+	}
+
+	// Always end with defaultLocale if not already in chain
+	if (!visited.has(_config.defaultLocale)) {
+		chain.push(_config.defaultLocale);
+	}
+
+	return chain;
+}

package/src/import/index.ts

@@ -0,0 +1,90 @@
+/**
+ * Import system
+ *
+ * Provides a pluggable system for importing content from various sources.
+ */
+
+// Core types
+export type {
+	ImportSource,
+	ImportAnalysis,
+	ImportContext,
+	SourceInput,
+	FileInput,
+	UrlInput,
+	OAuthInput,
+	SourceProbeResult,
+	ProbeResult,
+	SourceAuth,
+	SourceCapabilities,
+	SuggestedAction,
+	PostTypeAnalysis,
+	ImportFieldDef,
+	FieldCompatibility,
+	CollectionSchemaStatus,
+	AttachmentInfo,
+	NormalizedItem,
+	ImportConfig,
+	ImportResult,
+	FetchOptions,
+	PostTypeMapping,
+	NavMenuAnalysis,
+	TaxonomyAnalysis,
+} from "./types.js";
+
+// Menu import
+export {
+	importMenusFromWxr,
+	importMenusFromPlugin,
+	type MenuImportResult,
+	type PluginMenu,
+	type PluginMenuItem,
+} from "./menus.js";
+
+// Sections import
+export { importReusableBlocksAsSections, type SectionsImportResult } from "./sections.js";
+
+// Site settings import
+export {
+	importSiteSettings,
+	parseSiteSettingsFromPlugin,
+	type SiteSettingsAnalysis,
+	type SettingsImportResult,
+	type WidgetAreaAnalysis,
+} from "./settings.js";
+
+// Registry
+export {
+	registerSource,
+	getSource,
+	getAllSources,
+	getFileSources,
+	getUrlSources,
+	probeUrl,
+	clearSources,
+} from "./registry.js";
+
+// SSRF protection
+export { validateExternalUrl, ssrfSafeFetch, SsrfError } from "./ssrf.js";
+
+// Sources
+export { wxrSource } from "./sources/wxr.js";
+export { wordpressRestSource } from "./sources/wordpress-rest.js";
+export {
+	wordpressPluginSource,
+	createBasicAuthToken,
+	fetchPluginMedia,
+	fetchPluginTaxonomies,
+} from "./sources/wordpress-plugin.js";
+
+// Auto-register built-in sources
+import { registerSource } from "./registry.js";
+import { wordpressPluginSource } from "./sources/wordpress-plugin.js";
+import { wordpressRestSource } from "./sources/wordpress-rest.js";
+import { wxrSource } from "./sources/wxr.js";
+
+// Register in priority order (most specific first)
+// Plugin source first - if they have our plugin, use it
+registerSource(wordpressPluginSource);
+registerSource(wordpressRestSource);
+registerSource(wxrSource);

package/src/import/menus.ts

@@ -0,0 +1,436 @@
+/**
+ * Menu import functions
+ *
+ * Import navigation menus from WordPress WXR exports or plugin API.
+ */
+
+import type { Kysely } from "kysely";
+import { ulid } from "ulidx";
+
+import type { WxrNavMenu, WxrNavMenuItem } from "../cli/wxr/parser.js";
+import type { Database } from "../database/types.js";
+import type { MenuItemType } from "../menus/types.js";
+
+/**
+ * Result of menu import operation
+ */
+export interface MenuImportResult {
+	/** Number of menus created */
+	menusCreated: number;
+	/** Number of menu items created */
+	itemsCreated: number;
+	/** Mapping from WP menu slug to EmDash menu ID */
+	menuIdMap: Map<string, string>;
+	/** Errors encountered during import */
+	errors: Array<{ menu: string; error: string }>;
+}
+
+/**
+ * Plugin API menu format (matches /emdash/v1/menus response)
+ */
+export interface PluginMenu {
+	id: number;
+	name: string; // slug
+	label: string;
+	items: PluginMenuItem[];
+}
+
+export interface PluginMenuItem {
+	id: number;
+	parent_id: number | null;
+	sort_order: number;
+	type: "custom" | "post_type" | "taxonomy";
+	object: string | null; // 'page', 'post', 'category'
+	object_id: number | null;
+	url: string;
+	title: string;
+	target: string | null;
+	classes: string | null;
+}
+
+/**
+ * Import navigation menus from WXR export
+ *
+ * @param menus - Parsed navigation menus from WXR
+ * @param db - Database connection
+ * @param contentIdMap - Map from WP post ID to EmDash content ID (for resolving references)
+ * @returns Import result with counts and ID mapping
+ */
+export async function importMenusFromWxr(
+	menus: WxrNavMenu[],
+	db: Kysely<Database>,
+	contentIdMap: Map<number, string>,
+): Promise<MenuImportResult> {
+	const result: MenuImportResult = {
+		menusCreated: 0,
+		itemsCreated: 0,
+		menuIdMap: new Map(),
+		errors: [],
+	};
+
+	for (const menu of menus) {
+		try {
+			// Check if menu already exists
+			const existing = await db
+				.selectFrom("_emdash_menus")
+				.select("id")
+				.where("name", "=", menu.name)
+				.executeTakeFirst();
+
+			if (existing) {
+				result.menuIdMap.set(menu.name, existing.id);
+				continue; // Skip existing menus
+			}
+
+			// Create the menu
+			const menuId = ulid();
+			await db
+				.insertInto("_emdash_menus")
+				.values({
+					id: menuId,
+					name: menu.name,
+					label: menu.label,
+				})
+				.execute();
+
+			result.menusCreated++;
+			result.menuIdMap.set(menu.name, menuId);
+
+			// Import menu items
+			const itemsCreated = await importWxrMenuItems(menu.items, menuId, db, contentIdMap);
+			result.itemsCreated += itemsCreated;
+		} catch (error) {
+			result.errors.push({
+				menu: menu.name,
+				error: error instanceof Error ? error.message : String(error),
+			});
+		}
+	}
+
+	return result;
+}
+
+/**
+ * Import navigation menus from Plugin API
+ *
+ * @param menus - Menus from plugin API
+ * @param db - Database connection
+ * @param contentIdMap - Map from WP post ID to EmDash content ID
+ * @returns Import result with counts and ID mapping
+ */
+export async function importMenusFromPlugin(
+	menus: PluginMenu[],
+	db: Kysely<Database>,
+	contentIdMap: Map<number, string>,
+): Promise<MenuImportResult> {
+	const result: MenuImportResult = {
+		menusCreated: 0,
+		itemsCreated: 0,
+		menuIdMap: new Map(),
+		errors: [],
+	};
+
+	for (const menu of menus) {
+		try {
+			// Check if menu already exists
+			const existing = await db
+				.selectFrom("_emdash_menus")
+				.select("id")
+				.where("name", "=", menu.name)
+				.executeTakeFirst();
+
+			if (existing) {
+				result.menuIdMap.set(menu.name, existing.id);
+				continue;
+			}
+
+			// Create the menu
+			const menuId = ulid();
+			await db
+				.insertInto("_emdash_menus")
+				.values({
+					id: menuId,
+					name: menu.name,
+					label: menu.label,
+				})
+				.execute();
+
+			result.menusCreated++;
+			result.menuIdMap.set(menu.name, menuId);
+
+			// Import menu items
+			const itemsCreated = await importPluginMenuItems(menu.items, menuId, db, contentIdMap);
+			result.itemsCreated += itemsCreated;
+		} catch (error) {
+			result.errors.push({
+				menu: menu.name,
+				error: error instanceof Error ? error.message : String(error),
+			});
+		}
+	}
+
+	return result;
+}
+
+/**
+ * Import menu items from WXR format
+ */
+async function importWxrMenuItems(
+	items: WxrNavMenuItem[],
+	menuId: string,
+	db: Kysely<Database>,
+	contentIdMap: Map<number, string>,
+): Promise<number> {
+	// Build a map of WP menu item IDs to EmDash IDs for parent resolution
+	const itemIdMap = new Map<number, string>();
+	let count = 0;
+
+	// Sort items by sort order to maintain hierarchy
+	const sortedItems = items.toSorted((a, b) => a.sortOrder - b.sortOrder);
+
+	// First pass: create all items with temporary parent IDs
+	for (const item of sortedItems) {
+		const itemId = ulid();
+		itemIdMap.set(item.id, itemId);
+
+		const { type, collection, referenceId, customUrl } = mapWxrMenuItem(item, contentIdMap);
+
+		await db
+			.insertInto("_emdash_menu_items")
+			.values({
+				id: itemId,
+				menu_id: menuId,
+				parent_id: null, // Will be set in second pass
+				sort_order: item.sortOrder,
+				type,
+				reference_collection: collection,
+				reference_id: referenceId,
+				custom_url: customUrl,
+				label: item.title,
+				title_attr: null,
+				target: item.target || null,
+				css_classes: item.classes || null,
+			})
+			.execute();
+
+		count++;
+	}
+
+	// Second pass: update parent IDs
+	for (const item of sortedItems) {
+		if (item.parentId) {
+			const itemId = itemIdMap.get(item.id);
+			const parentId = itemIdMap.get(item.parentId);
+
+			if (itemId && parentId) {
+				await db
+					.updateTable("_emdash_menu_items")
+					.set({ parent_id: parentId })
+					.where("id", "=", itemId)
+					.execute();
+			}
+		}
+	}
+
+	return count;
+}
+
+/**
+ * Import menu items from Plugin API format
+ */
+async function importPluginMenuItems(
+	items: PluginMenuItem[],
+	menuId: string,
+	db: Kysely<Database>,
+	contentIdMap: Map<number, string>,
+): Promise<number> {
+	const itemIdMap = new Map<number, string>();
+	let count = 0;
+
+	const sortedItems = items.toSorted((a, b) => a.sort_order - b.sort_order);
+
+	for (const item of sortedItems) {
+		const itemId = ulid();
+		itemIdMap.set(item.id, itemId);
+
+		const { type, collection, referenceId, customUrl } = mapPluginMenuItem(item, contentIdMap);
+
+		await db
+			.insertInto("_emdash_menu_items")
+			.values({
+				id: itemId,
+				menu_id: menuId,
+				parent_id: null,
+				sort_order: item.sort_order,
+				type,
+				reference_collection: collection,
+				reference_id: referenceId,
+				custom_url: customUrl,
+				label: item.title,
+				title_attr: null,
+				target: item.target || null,
+				css_classes: item.classes || null,
+			})
+			.execute();
+
+		count++;
+	}
+
+	// Second pass: update parent IDs
+	for (const item of sortedItems) {
+		if (item.parent_id) {
+			const itemId = itemIdMap.get(item.id);
+			const parentId = itemIdMap.get(item.parent_id);
+
+			if (itemId && parentId) {
+				await db
+					.updateTable("_emdash_menu_items")
+					.set({ parent_id: parentId })
+					.where("id", "=", itemId)
+					.execute();
+			}
+		}
+	}
+
+	return count;
+}
+
+/**
+ * Map WXR menu item to EmDash format
+ */
+function mapWxrMenuItem(
+	item: WxrNavMenuItem,
+	contentIdMap: Map<number, string>,
+): {
+	type: MenuItemType;
+	collection: string | null;
+	referenceId: string | null;
+	customUrl: string | null;
+} {
+	switch (item.type) {
+		case "custom":
+			return {
+				type: "custom",
+				collection: null,
+				referenceId: null,
+				customUrl: item.url || "#",
+			};
+
+		case "post_type": {
+			// Map WordPress object type to collection
+			const collection = mapObjectToCollection(item.objectType);
+			const referenceId = item.objectId ? contentIdMap.get(item.objectId) || null : null;
+
+			// If we can't resolve the reference, fall back to custom URL
+			if (!referenceId && item.url) {
+				return {
+					type: "custom",
+					collection: null,
+					referenceId: null,
+					customUrl: item.url,
+				};
+			}
+
+			return {
+				type: collection === "pages" ? "page" : "post",
+				collection,
+				referenceId,
+				customUrl: null,
+			};
+		}
+
+		case "taxonomy":
+			// For taxonomies, we need taxonomy support in menus
+			// Fall back to custom URL for now
+			return {
+				type: "custom",
+				collection: null,
+				referenceId: null,
+				customUrl: item.url || "#",
+			};
+
+		default:
+			return {
+				type: "custom",
+				collection: null,
+				referenceId: null,
+				customUrl: item.url || "#",
+			};
+	}
+}
+
+/**
+ * Map Plugin menu item to EmDash format
+ */
+function mapPluginMenuItem(
+	item: PluginMenuItem,
+	contentIdMap: Map<number, string>,
+): {
+	type: MenuItemType;
+	collection: string | null;
+	referenceId: string | null;
+	customUrl: string | null;
+} {
+	switch (item.type) {
+		case "custom":
+			return {
+				type: "custom",
+				collection: null,
+				referenceId: null,
+				customUrl: item.url || "#",
+			};
+
+		case "post_type": {
+			const collection = mapObjectToCollection(item.object);
+			const referenceId = item.object_id ? contentIdMap.get(item.object_id) || null : null;
+
+			if (!referenceId && item.url) {
+				return {
+					type: "custom",
+					collection: null,
+					referenceId: null,
+					customUrl: item.url,
+				};
+			}
+
+			return {
+				type: collection === "pages" ? "page" : "post",
+				collection,
+				referenceId,
+				customUrl: null,
+			};
+		}
+
+		case "taxonomy":
+			return {
+				type: "custom",
+				collection: null,
+				referenceId: null,
+				customUrl: item.url || "#",
+			};
+
+		default:
+			return {
+				type: "custom",
+				collection: null,
+				referenceId: null,
+				customUrl: item.url || "#",
+			};
+	}
+}
+
+/**
+ * Map WordPress object type to EmDash collection name
+ */
+function mapObjectToCollection(objectType: string | undefined | null): string {
+	if (!objectType) return "posts";
+
+	const mapping: Record<string, string> = {
+		post: "posts",
+		page: "pages",
+		product: "products",
+		portfolio: "portfolio",
+	};
+
+	return mapping[objectType] || objectType;
+}