dineway 0.1.8 → 0.1.11

package/dist/astro/routes/api/import/wordpress/execute.mjs

@@ -0,0 +1,197 @@
+import "../../../../../dialect-helpers-DhTzaUxP.mjs";
+import { n as slugify } from "../../../../../slugify-PDTDtMXp.mjs";
+import "../../../../../content-CyLkb-qH.mjs";
+import "../../../../../base64-Cz-aU0X1.mjs";
+import "../../../../../types-Bs6lTBBW.mjs";
+import "../../../../../media-_7Fxdu45.mjs";
+import "../../../../../options-z8VVg1Ll.mjs";
+import "../../../../../site-activity-B8FjLIVh.mjs";
+import "../../../../../review-requests-C2DIHwlJ.mjs";
+import "../../../../../entity-aliases-C0v-yNET.mjs";
+import { t as BylineRepository } from "../../../../../byline-naZxOPSa.mjs";
+import "../../../../../briefing-BrXCuMEE.mjs";
+import "../../../../../context-types-C-LwdAxx.mjs";
+import "../../../../../fts-manager-B1pTNEG_.mjs";
+import "../../../../../registry-C-_hxLqa.mjs";
+import "../../../../../loader-PZnPxFLc.mjs";
+import "../../../../../settings-4XnpVMOS.mjs";
+import "../../../../../request-cache-DHMRr2Lf.mjs";
+import "../../../../../schema-BNpI53of.mjs";
+import "../../../../../zod-generator-DBVP8D0P.mjs";
+import { n as apiSuccess, r as handleError, t as apiError } from "../../../../../error-DEGjx2Xw.mjs";
+import { m as resolveImportByline } from "../../../../../utils-D2in-zwy.mjs";
+import { t as sanitizeWordPressImportSlug } from "../../../../../wordpress-slugs-BevajWrC.mjs";
+import "../../../../../search-DM6CVti3.mjs";
+import { n as requirePerm } from "../../../../../authorize-BBj8C6Y8.mjs";
+import { _ as RiskPolicyEvaluator, p as WordPressImportHitlPayloadBuilder } from "../../../../../site-context-Bpu_Paur.mjs";
+import "../../../../../activity-events-BsMaXdJa.mjs";
+import { i as resolveHitlRouteActor, n as hitlRequiredRouteError, t as ensureWorkflowHitlRouteRequest } from "../../../../../hitl-route-helpers-DMmJRS7B.mjs";
+import { gutenbergToPortableText } from "@dineway-ai/gutenberg-to-portable-text";
+import { ContentRepository, importReusableBlocksAsSections, parseWxrDate, parseWxrString } from "dineway";
+
+//#region src/astro/routes/api/import/wordpress/execute.ts
+/**
+* WordPress WXR execute import endpoint
+*
+* POST /_dineway/api/import/wordpress/execute
+*
+* Accepts WXR file and import configuration, imports content into the database.
+*/
+const prerender = false;
+const POST = async ({ request, locals }) => {
+	const { dineway, user } = locals;
+	const denied = requirePerm(user, "import:execute");
+	if (denied) return denied;
+	if (!dineway?.handleContentCreate) return apiError("NOT_CONFIGURED", "Dineway is not configured", 500);
+	try {
+		const formData = await request.formData();
+		const fileEntry = formData.get("file");
+		const file = fileEntry instanceof File ? fileEntry : null;
+		const configEntry = formData.get("config");
+		const configJson = typeof configEntry === "string" ? configEntry : null;
+		const hitlRequestEntry = formData.get("hitlRequestId");
+		const hitlRequestId = typeof hitlRequestEntry === "string" && hitlRequestEntry.length > 0 ? hitlRequestEntry : void 0;
+		if (!file) return apiError("VALIDATION_ERROR", "No file provided", 400);
+		if (!configJson) return apiError("VALIDATION_ERROR", "No config provided", 400);
+		const config = JSON.parse(configJson);
+		const actor = resolveHitlRouteActor(locals);
+		const evaluator = new RiskPolicyEvaluator({
+			db: dineway.db,
+			handlers: dineway
+		});
+		let text;
+		if (evaluator.requiresWorkflowHitl(actor.identity)) {
+			const fileBuffer = await file.arrayBuffer();
+			const action = await new WordPressImportHitlPayloadBuilder().buildExecuteRequest({
+				fileName: file.name,
+				fileBuffer,
+				config
+			});
+			const decision = await evaluator.evaluateWorkflowHitl({
+				actor: actor.identity,
+				hitlRequestId,
+				action
+			});
+			if (!decision.allowed) return hitlRequiredRouteError(decision, await ensureWorkflowHitlRouteRequest(dineway.db, locals, decision.action));
+			text = new TextDecoder().decode(fileBuffer);
+		} else text = await file.text();
+		const wxr = await parseWxrString(text);
+		const manifest = await dineway.getManifest();
+		const attachmentMap = /* @__PURE__ */ new Map();
+		for (const att of wxr.attachments) if (att.id && att.url) attachmentMap.set(String(att.id), att.url);
+		const authorDisplayNames = /* @__PURE__ */ new Map();
+		for (const author of wxr.authors) {
+			if (!author.login) continue;
+			authorDisplayNames.set(author.login, author.displayName || author.login);
+		}
+		const result = await importContent(wxr.posts, config, dineway, manifest, attachmentMap, config.locale, authorDisplayNames);
+		if (config.importSections !== false) {
+			const sectionsResult = await importReusableBlocksAsSections(wxr.posts, dineway.db);
+			result.sections = {
+				created: sectionsResult.sectionsCreated,
+				skipped: sectionsResult.sectionsSkipped
+			};
+			result.errors.push(...sectionsResult.errors);
+			if (sectionsResult.errors.length > 0) result.success = false;
+		}
+		return apiSuccess(result);
+	} catch (error) {
+		return handleError(error, "Failed to import content", "WXR_IMPORT_ERROR");
+	}
+};
+async function importContent(posts, config, dineway, manifest, attachmentMap, locale, authorDisplayNames) {
+	const result = {
+		success: true,
+		imported: 0,
+		skipped: 0,
+		errors: [],
+		byCollection: {}
+	};
+	const contentRepo = new ContentRepository(dineway.db);
+	const bylineRepo = new BylineRepository(dineway.db);
+	const bylineCache = /* @__PURE__ */ new Map();
+	for (const post of posts) {
+		const postType = post.postType || "post";
+		const mapping = config.postTypeMappings[postType];
+		if (!mapping || !mapping.enabled) {
+			result.skipped++;
+			continue;
+		}
+		const collection = sanitizeWordPressImportSlug(mapping.collection);
+		if (!manifest?.collections[collection]) {
+			result.errors.push({
+				title: post.title || "Untitled",
+				error: `Collection "${collection}" does not exist`
+			});
+			continue;
+		}
+		try {
+			const content = post.content ? gutenbergToPortableText(post.content) : [];
+			const slug = post.postName || slugify(post.title || `post-${post.id || Date.now()}`);
+			if (config.skipExisting) {
+				if (await contentRepo.findBySlug(collection, slug)) {
+					result.skipped++;
+					continue;
+				}
+			}
+			const status = mapStatus(post.status);
+			const data = {
+				title: post.title || "Untitled",
+				content,
+				excerpt: post.excerpt || void 0
+			};
+			const collectionSchema = manifest.collections[collection];
+			if (collectionSchema?.fields ? "featured_image" in collectionSchema.fields : false) {
+				const thumbnailId = post.meta.get("_thumbnail_id");
+				const featuredImage = thumbnailId ? attachmentMap.get(String(thumbnailId)) : void 0;
+				if (featuredImage) data.featured_image = featuredImage;
+			}
+			let authorId;
+			if (config.authorMappings && post.creator) {
+				const mappedUserId = config.authorMappings[post.creator];
+				if (mappedUserId !== void 0 && mappedUserId !== null) authorId = mappedUserId;
+			}
+			const bylineId = await resolveImportByline(post.creator, authorDisplayNames?.get(post.creator ?? "") ?? post.creator, authorId, bylineRepo, bylineCache);
+			const parsedDate = parseWxrDate(post.postDateGmt, post.pubDate, post.postDate);
+			const createdAt = parsedDate ? parsedDate.toISOString() : void 0;
+			const publishedAt = status === "published" && createdAt ? createdAt : void 0;
+			const createResult = await dineway.handleContentCreate(collection, {
+				data,
+				slug,
+				status,
+				authorId,
+				bylines: bylineId ? [{ bylineId }] : void 0,
+				locale,
+				createdAt,
+				publishedAt
+			});
+			if (createResult.success) {
+				result.imported++;
+				result.byCollection[collection] = (result.byCollection[collection] || 0) + 1;
+			} else result.errors.push({
+				title: post.title || "Untitled",
+				error: typeof createResult.error === "object" && createResult.error !== null ? createResult.error.message || "Unknown error" : String(createResult.error)
+			});
+		} catch (error) {
+			console.error(`Import error for "${post.title || "Untitled"}":`, error);
+			result.errors.push({
+				title: post.title || "Untitled",
+				error: error instanceof Error && error.message ? error.message : "Failed to import item"
+			});
+		}
+	}
+	result.success = result.errors.length === 0;
+	return result;
+}
+function mapStatus(wpStatus) {
+	switch (wpStatus) {
+		case "publish": return "published";
+		case "draft": return "draft";
+		case "pending": return "draft";
+		case "private": return "draft";
+		default: return "draft";
+	}
+}
+
+//#endregion
+export { POST, prerender };

package/dist/astro/routes/api/import/wordpress/media.d.mts

@@ -0,0 +1,35 @@
+import { APIRoute } from "astro";
+
+//#region src/astro/routes/api/import/wordpress/media.d.ts
+declare const prerender = false;
+/** Progress update sent during streaming */
+interface MediaImportProgress {
+  type: "progress";
+  current: number;
+  total: number;
+  filename?: string;
+  status: "downloading" | "uploading" | "done" | "skipped" | "failed";
+  error?: string;
+}
+/** Final result sent at end of stream */
+interface MediaImportResult {
+  type?: "result";
+  /** Successfully imported items */
+  imported: Array<{
+    wpId?: number;
+    originalUrl: string;
+    newUrl: string;
+    mediaId: string;
+  }>;
+  /** Failed items */
+  failed: Array<{
+    wpId?: number;
+    originalUrl: string;
+    error: string;
+  }>;
+  /** Map of old URLs to new URLs (for content rewriting) */
+  urlMap: Record<string, string>;
+}
+declare const POST: APIRoute;
+//#endregion
+export { MediaImportProgress, MediaImportResult, POST, prerender };

package/dist/astro/routes/api/import/wordpress/media.mjs

@@ -0,0 +1,222 @@
+import "../../../../../context-types-C-LwdAxx.mjs";
+import { n as apiSuccess, r as handleError, t as apiError } from "../../../../../error-DEGjx2Xw.mjs";
+import { n as parseBody, t as isParseError } from "../../../../../parse-BeQXIt1U.mjs";
+import "../../../../../redirects-CqaxraTO.mjs";
+import { n as wpMediaImportBody } from "../../../../../import-DD3f2jkc.mjs";
+import "../../../../../api/schemas/index.mjs";
+import { a as validateExternalUrl, r as ssrfSafeFetch, t as SsrfError } from "../../../../../ssrf-CmM76lLV.mjs";
+import { n as requirePerm } from "../../../../../authorize-BBj8C6Y8.mjs";
+import { ulid } from "ulidx";
+import * as path from "node:path";
+import mime from "mime/lite";
+import { MediaRepository, computeContentHash } from "dineway";
+
+//#region src/astro/routes/api/import/wordpress/media.ts
+/**
+* WordPress media import endpoint
+*
+* POST /_dineway/api/import/wordpress/media
+*
+* Downloads media attachments from WordPress URLs and uploads to Dineway storage.
+* Streams progress updates as newline-delimited JSON (NDJSON).
+* Each line is either a progress update or the final result.
+*/
+const prerender = false;
+const POST = async ({ request, locals }) => {
+	const { dineway, user } = locals;
+	const denied = requirePerm(user, "import:execute");
+	if (denied) return denied;
+	if (!dineway?.storage) return apiError("NO_STORAGE", "Storage not configured. Media import requires storage.", 501);
+	if (!dineway?.db) return apiError("NO_DB", "Database not initialized", 500);
+	try {
+		const body = await parseBody(request, wpMediaImportBody);
+		if (isParseError(body)) return body;
+		const attachments = body.attachments;
+		if (body.stream !== false) {
+			const stream = new ReadableStream({ async start(controller) {
+				const encoder = new TextEncoder();
+				const sendProgress = (progress) => {
+					controller.enqueue(encoder.encode(JSON.stringify(progress) + "\n"));
+				};
+				const result = await importMediaWithProgress(attachments, dineway.db, dineway.storage, sendProgress);
+				controller.enqueue(encoder.encode(JSON.stringify({
+					...result,
+					type: "result"
+				}) + "\n"));
+				controller.close();
+			} });
+			return new Response(stream, {
+				status: 200,
+				headers: {
+					"Content-Type": "application/x-ndjson",
+					"Cache-Control": "private, no-store",
+					"Transfer-Encoding": "chunked"
+				}
+			});
+		}
+		return apiSuccess(await importMediaWithProgress(attachments, dineway.db, dineway.storage, () => {}));
+	} catch (error) {
+		return handleError(error, "Failed to import media", "IMPORT_ERROR");
+	}
+};
+async function importMediaWithProgress(attachments, db, storage, onProgress) {
+	const repo = new MediaRepository(db);
+	const total = attachments.length;
+	const result = {
+		imported: [],
+		failed: [],
+		urlMap: {}
+	};
+	for (let i = 0; i < attachments.length; i++) {
+		const attachment = attachments[i];
+		const current = i + 1;
+		const filename = attachment.filename || `file-${attachment.id}`;
+		if (!attachment.url) {
+			result.failed.push({
+				wpId: attachment.id,
+				originalUrl: "",
+				error: "No URL provided"
+			});
+			onProgress({
+				type: "progress",
+				current,
+				total,
+				filename,
+				status: "failed",
+				error: "No URL provided"
+			});
+			continue;
+		}
+		try {
+			try {
+				validateExternalUrl(attachment.url);
+			} catch (e) {
+				const msg = e instanceof SsrfError ? e.message : "Invalid URL";
+				result.failed.push({
+					wpId: attachment.id,
+					originalUrl: attachment.url,
+					error: `Blocked: ${msg}`
+				});
+				onProgress({
+					type: "progress",
+					current,
+					total,
+					filename,
+					status: "failed",
+					error: `Blocked: ${msg}`
+				});
+				continue;
+			}
+			onProgress({
+				type: "progress",
+				current,
+				total,
+				filename,
+				status: "downloading"
+			});
+			const response = await ssrfSafeFetch(attachment.url, { headers: { "User-Agent": "Dineway-Importer/1.0" } });
+			if (!response.ok) {
+				result.failed.push({
+					wpId: attachment.id,
+					originalUrl: attachment.url,
+					error: `HTTP ${response.status}: ${response.statusText}`
+				});
+				onProgress({
+					type: "progress",
+					current,
+					total,
+					filename,
+					status: "failed",
+					error: `HTTP ${response.status}`
+				});
+				continue;
+			}
+			const contentType = response.headers.get("content-type") || attachment.mimeType || "application/octet-stream";
+			const buffer = await response.arrayBuffer();
+			const size = buffer.byteLength;
+			const contentHash = await computeContentHash(buffer);
+			const existing = await repo.findByContentHash(contentHash);
+			if (existing) {
+				const existingUrl = `/_dineway/api/media/file/${existing.storageKey}`;
+				result.urlMap[attachment.url] = existingUrl;
+				result.imported.push({
+					wpId: attachment.id,
+					originalUrl: attachment.url,
+					newUrl: existingUrl,
+					mediaId: existing.id
+				});
+				onProgress({
+					type: "progress",
+					current,
+					total,
+					filename,
+					status: "skipped"
+				});
+				continue;
+			}
+			onProgress({
+				type: "progress",
+				current,
+				total,
+				filename,
+				status: "uploading"
+			});
+			const id = ulid();
+			const ext = attachment.filename ? path.extname(attachment.filename) : getExtensionFromMimeType(contentType);
+			const storageKey = `${id}${ext}`;
+			await storage.upload({
+				key: storageKey,
+				body: new Uint8Array(buffer),
+				contentType
+			});
+			const mediaItem = await repo.create({
+				filename: attachment.filename || `media-${attachment.id}${ext}`,
+				mimeType: contentType,
+				size,
+				storageKey,
+				contentHash,
+				width: void 0,
+				height: void 0
+			});
+			const newUrl = `/_dineway/api/media/file/${storageKey}`;
+			result.imported.push({
+				wpId: attachment.id,
+				originalUrl: attachment.url,
+				newUrl,
+				mediaId: mediaItem.id
+			});
+			result.urlMap[attachment.url] = newUrl;
+			onProgress({
+				type: "progress",
+				current,
+				total,
+				filename,
+				status: "done"
+			});
+		} catch (error) {
+			console.error(`Media import error for "${filename}":`, error);
+			const errorMsg = "Failed to import media";
+			result.failed.push({
+				wpId: attachment.id,
+				originalUrl: attachment.url,
+				error: errorMsg
+			});
+			onProgress({
+				type: "progress",
+				current,
+				total,
+				filename,
+				status: "failed",
+				error: errorMsg
+			});
+		}
+	}
+	return result;
+}
+function getExtensionFromMimeType(mimeType) {
+	const ext = mime.getExtension(mimeType);
+	return ext ? `.${ext}` : "";
+}
+
+//#endregion
+export { POST, prerender };

package/dist/astro/routes/api/import/wordpress/prepare.d.mts

@@ -0,0 +1,19 @@
+import { APIRoute } from "astro";
+
+//#region src/astro/routes/api/import/wordpress/prepare.d.ts
+declare const prerender = false;
+interface PrepareResult {
+  success: boolean;
+  collectionsCreated: string[];
+  fieldsCreated: Array<{
+    collection: string;
+    field: string;
+  }>;
+  errors: Array<{
+    collection: string;
+    error: string;
+  }>;
+}
+declare const POST: APIRoute;
+//#endregion
+export { POST, PrepareResult, prerender };

package/dist/astro/routes/api/import/wordpress/prepare.mjs

@@ -0,0 +1,155 @@
+import "../../../../../dialect-helpers-DhTzaUxP.mjs";
+import "../../../../../content-CyLkb-qH.mjs";
+import "../../../../../base64-Cz-aU0X1.mjs";
+import "../../../../../types-Bs6lTBBW.mjs";
+import "../../../../../media-_7Fxdu45.mjs";
+import "../../../../../options-z8VVg1Ll.mjs";
+import "../../../../../site-activity-B8FjLIVh.mjs";
+import "../../../../../review-requests-C2DIHwlJ.mjs";
+import "../../../../../entity-aliases-C0v-yNET.mjs";
+import "../../../../../briefing-BrXCuMEE.mjs";
+import "../../../../../context-types-C-LwdAxx.mjs";
+import "../../../../../fts-manager-B1pTNEG_.mjs";
+import { t as FIELD_TYPES } from "../../../../../types-DL7Y8D_t.mjs";
+import "../../../../../registry-C-_hxLqa.mjs";
+import "../../../../../loader-PZnPxFLc.mjs";
+import "../../../../../settings-4XnpVMOS.mjs";
+import "../../../../../request-cache-DHMRr2Lf.mjs";
+import "../../../../../schema-BNpI53of.mjs";
+import "../../../../../zod-generator-DBVP8D0P.mjs";
+import { n as apiSuccess, r as handleError, t as apiError } from "../../../../../error-DEGjx2Xw.mjs";
+import { n as parseBody, t as isParseError } from "../../../../../parse-BeQXIt1U.mjs";
+import "../../../../../redirects-CqaxraTO.mjs";
+import { a as wpPrepareBody } from "../../../../../import-DD3f2jkc.mjs";
+import "../../../../../api/schemas/index.mjs";
+import "../../../../../utils-D2in-zwy.mjs";
+import { t as sanitizeWordPressImportSlug } from "../../../../../wordpress-slugs-BevajWrC.mjs";
+import "../../../../../search-DM6CVti3.mjs";
+import { n as requirePerm } from "../../../../../authorize-BBj8C6Y8.mjs";
+import { _ as RiskPolicyEvaluator, p as WordPressImportHitlPayloadBuilder } from "../../../../../site-context-Bpu_Paur.mjs";
+import "../../../../../activity-events-BsMaXdJa.mjs";
+import { i as resolveHitlRouteActor, n as hitlRequiredRouteError, t as ensureWorkflowHitlRouteRequest } from "../../../../../hitl-route-helpers-DMmJRS7B.mjs";
+import { capitalize, singularize } from "./analyze.mjs";
+import { z } from "zod";
+
+//#region src/astro/routes/api/import/wordpress/prepare.ts
+/** Validate that a string is a known FieldType, returning undefined if not */
+function asFieldType(value) {
+	return FIELD_TYPES.includes(value) ? value : void 0;
+}
+const prerender = false;
+const prepareBodySchema = wpPrepareBody.extend({ hitlRequestId: z.string().min(1).optional() });
+const POST = async ({ request, locals }) => {
+	const { dineway, user } = locals;
+	if (!dineway?.db) return apiError("NOT_CONFIGURED", "Dineway is not configured", 500);
+	const denied = requirePerm(user, "import:execute");
+	if (denied) return denied;
+	try {
+		const body = await parseBody(request, prepareBodySchema);
+		if (isParseError(body)) return body;
+		const actor = resolveHitlRouteActor(locals);
+		const evaluator = new RiskPolicyEvaluator({
+			db: dineway.db,
+			handlers: dineway
+		});
+		const action = await new WordPressImportHitlPayloadBuilder().buildPrepareRequest({ postTypes: body.postTypes });
+		const decision = await evaluator.evaluateWorkflowHitl({
+			actor: actor.identity,
+			hitlRequestId: body.hitlRequestId,
+			action
+		});
+		if (!decision.allowed) return hitlRequiredRouteError(decision, await ensureWorkflowHitlRouteRequest(dineway.db, locals, decision.action));
+		const result = await prepareImport(dineway.db, { postTypes: body.postTypes });
+		if (result.collectionsCreated.length > 0 || result.fieldsCreated.length > 0) dineway.invalidateManifest();
+		return apiSuccess(result, result.success ? 200 : 400);
+	} catch (error) {
+		return handleError(error, "Failed to prepare import", "WXR_PREPARE_ERROR");
+	}
+};
+async function prepareImport(db, request) {
+	const { SchemaRegistry } = await import("../../../../../registry-C-_hxLqa.mjs").then((n) => n.r);
+	const registry = new SchemaRegistry(db);
+	const result = {
+		success: true,
+		collectionsCreated: [],
+		fieldsCreated: [],
+		errors: []
+	};
+	for (const postType of request.postTypes) {
+		const collectionSlug = sanitizeWordPressImportSlug(postType.collection);
+		try {
+			let collection = await registry.getCollection(collectionSlug);
+			if (!collection) {
+				const label = capitalize(collectionSlug);
+				const labelSingular = capitalize(singularize(collectionSlug));
+				const isSearchable = [
+					"posts",
+					"pages",
+					"post",
+					"page"
+				].includes(collectionSlug);
+				const supports = ["revisions", "drafts"];
+				if (isSearchable) supports.push("search");
+				const urlPattern = collectionSlug === "pages" ? "/{slug}" : collectionSlug === "posts" ? "/blog/{slug}" : void 0;
+				collection = await registry.createCollection({
+					slug: collectionSlug,
+					label,
+					labelSingular,
+					description: `Imported from WordPress post type: ${postType.name}`,
+					supports,
+					urlPattern
+				});
+				result.collectionsCreated.push(collectionSlug);
+			}
+			const existingFields = await registry.listFields(collection.id);
+			const existingFieldSlugs = new Set(existingFields.map((f) => f.slug));
+			for (const field of postType.fields) {
+				if (existingFieldSlugs.has(field.slug)) continue;
+				const fieldType = asFieldType(field.type);
+				if (!fieldType) {
+					result.errors.push({
+						collection: collectionSlug,
+						error: `Unknown field type "${field.type}" for field "${field.slug}"`
+					});
+					continue;
+				}
+				await registry.createField(collectionSlug, {
+					slug: field.slug,
+					label: field.label,
+					type: fieldType,
+					required: field.required,
+					unique: false,
+					searchable: field.searchable ?? false,
+					sortOrder: existingFields.length + result.fieldsCreated.length
+				});
+				result.fieldsCreated.push({
+					collection: collectionSlug,
+					field: field.slug
+				});
+			}
+			if ([
+				"posts",
+				"pages",
+				"post",
+				"page"
+			].includes(collectionSlug)) {
+				const { FTSManager } = await import("../../../../../fts-manager-B1pTNEG_.mjs").then((n) => n.n);
+				const ftsManager = new FTSManager(db);
+				if ((await ftsManager.getSearchableFields(collectionSlug)).length > 0) try {
+					await ftsManager.enableSearch(collectionSlug);
+				} catch {}
+			}
+		} catch (error) {
+			console.error(`Prepare error for collection "${collectionSlug}":`, error);
+			result.success = false;
+			result.errors.push({
+				collection: collectionSlug,
+				error: "Failed to prepare collection"
+			});
+		}
+	}
+	return result;
+}
+
+//#endregion
+export { POST, prerender };

package/dist/astro/routes/api/import/wordpress/rewrite-urls.d.mts

@@ -0,0 +1,21 @@
+import { APIRoute } from "astro";
+
+//#region src/astro/routes/api/import/wordpress/rewrite-urls.d.ts
+declare const prerender = false;
+interface RewriteUrlsResult {
+  /** Total items updated */
+  updated: number;
+  /** Updates by collection */
+  byCollection: Record<string, number>;
+  /** URLs that were rewritten */
+  urlsRewritten: number;
+  /** Any errors encountered */
+  errors: Array<{
+    collection: string;
+    id: string;
+    error: string;
+  }>;
+}
+declare const POST: APIRoute;
+//#endregion
+export { POST, RewriteUrlsResult, prerender };