dineway 0.1.9 → 0.1.11

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

@@ -0,0 +1,289 @@
+import { t as validateIdentifier } from "../../../../../validate-VPnKoIzW.mjs";
+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 { t as normalizeMediaValue } from "../../../../../normalize-C49G_o1k.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 { n as parseBody, t as isParseError } from "../../../../../parse-BeQXIt1U.mjs";
+import "../../../../../redirects-CqaxraTO.mjs";
+import { o as wpRewriteUrlsBody } from "../../../../../import-DD3f2jkc.mjs";
+import "../../../../../api/schemas/index.mjs";
+import "../../../../../utils-D2in-zwy.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 { sql } from "kysely";
+import { z } from "zod";
+
+//#region src/astro/routes/api/import/wordpress/rewrite-urls.ts
+const prerender = false;
+const rewriteUrlsBodySchema = wpRewriteUrlsBody.extend({ hitlRequestId: z.string().min(1).optional() });
+const REGEX_SPECIAL_CHARS = /[.*+?^${}()|[\]\\]/g;
+const POST = async ({ request, locals }) => {
+	const { dineway, user } = locals;
+	if (!dineway?.db) return apiError("NO_DB", "Database not initialized", 500);
+	const denied = requirePerm(user, "import:execute");
+	if (denied) return denied;
+	try {
+		const body = await parseBody(request, rewriteUrlsBodySchema);
+		if (isParseError(body)) return body;
+		if (Object.entries(body.urlMap).length === 0) return apiSuccess({
+			updated: 0,
+			byCollection: {},
+			urlsRewritten: 0,
+			errors: []
+		});
+		const actor = resolveHitlRouteActor(locals);
+		const evaluator = new RiskPolicyEvaluator({
+			db: dineway.db,
+			handlers: dineway
+		});
+		const action = await new WordPressImportHitlPayloadBuilder().buildRewriteUrlsRequest({
+			urlMap: body.urlMap,
+			collections: body.collections
+		});
+		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 getProvider = (id) => dineway.getMediaProvider(id);
+		return apiSuccess(await rewriteUrls(dineway.db, body.urlMap, getProvider, body.collections));
+	} catch (error) {
+		return handleError(error, "Failed to rewrite URLs", "REWRITE_ERROR");
+	}
+};
+/**
+* Strip query parameters from a URL for base matching
+*/
+function getBaseUrl(url) {
+	try {
+		const parsed = new URL(url);
+		return `${parsed.origin}${parsed.pathname}`;
+	} catch {
+		return url.split("?")[0] || url;
+	}
+}
+/**
+* Build a map of base URLs to new URLs for flexible matching
+*/
+function buildBaseUrlMap(urlMap) {
+	const baseMap = /* @__PURE__ */ new Map();
+	for (const [oldUrl, newUrl] of Object.entries(urlMap)) {
+		const baseUrl = getBaseUrl(oldUrl);
+		baseMap.set(baseUrl, newUrl);
+	}
+	return baseMap;
+}
+/**
+* Find matching new URL for a given URL, checking both exact and base matches
+*/
+function findMatchingUrl(url, exactMap, baseMap) {
+	if (exactMap[url]) return exactMap[url];
+	const baseUrl = getBaseUrl(url);
+	const baseMatch = baseMap.get(baseUrl);
+	if (baseMatch) return baseMatch;
+	return null;
+}
+/**
+* Rewrite URLs in a Portable Text array, returning whether any changes were made
+*/
+function rewritePortableTextUrls(blocks, exactMap, baseMap) {
+	let changed = false;
+	let urlsRewritten = 0;
+	for (const block of blocks) {
+		if (block._type === "image" && block.asset?.url) {
+			const newUrl = findMatchingUrl(block.asset.url, exactMap, baseMap);
+			if (newUrl) {
+				block.asset.url = newUrl;
+				block.asset._ref = newUrl;
+				changed = true;
+				urlsRewritten++;
+			}
+		}
+		if (block._type === "image" && block.link) {
+			const newUrl = findMatchingUrl(block.link, exactMap, baseMap);
+			if (newUrl) {
+				block.link = newUrl;
+				changed = true;
+				urlsRewritten++;
+			}
+		}
+		if (block._type === "gallery" && Array.isArray(block.images)) {
+			const result = rewritePortableTextUrls(block.images, exactMap, baseMap);
+			if (result.changed) {
+				changed = true;
+				urlsRewritten += result.urlsRewritten;
+			}
+		}
+		if (block._type === "columns" && Array.isArray(block.columns)) {
+			for (const column of block.columns) if (Array.isArray(column.content)) {
+				const result = rewritePortableTextUrls(column.content, exactMap, baseMap);
+				if (result.changed) {
+					changed = true;
+					urlsRewritten += result.urlsRewritten;
+				}
+			}
+		}
+	}
+	return {
+		changed,
+		urlsRewritten
+	};
+}
+/**
+* Rewrite URLs in a string field using simple string replacement
+*/
+function rewriteStringUrls(value, exactMap, baseMap) {
+	let newValue = value;
+	let changed = false;
+	let urlsRewritten = 0;
+	for (const [oldUrl, newUrl] of Object.entries(exactMap)) if (newValue.includes(oldUrl)) {
+		newValue = newValue.split(oldUrl).join(newUrl);
+		changed = true;
+		urlsRewritten++;
+	}
+	for (const [baseUrl, newUrl] of baseMap.entries()) {
+		const regex = new RegExp(escapeRegExp(baseUrl) + "(\\?[^\"'\\s]*)?", "g");
+		const matches = newValue.match(regex);
+		if (matches) {
+			for (const match of matches) if (!exactMap[match]) {
+				newValue = newValue.split(match).join(newUrl);
+				changed = true;
+				urlsRewritten++;
+			}
+		}
+	}
+	return {
+		newValue,
+		changed,
+		urlsRewritten
+	};
+}
+/**
+* Escape special regex characters in a string
+*/
+function escapeRegExp(string) {
+	return string.replace(REGEX_SPECIAL_CHARS, "\\$&");
+}
+async function rewriteUrls(db, urlMap, getProvider, collections) {
+	const { SchemaRegistry } = await import("../../../../../registry-C-_hxLqa.mjs").then((n) => n.r);
+	const registry = new SchemaRegistry(db);
+	const result = {
+		updated: 0,
+		byCollection: {},
+		urlsRewritten: 0,
+		errors: []
+	};
+	const baseMap = buildBaseUrlMap(urlMap);
+	const allCollections = await registry.listCollections();
+	const targetCollections = collections?.length ? allCollections.filter((c) => collections.includes(c.slug)) : allCollections;
+	for (const collection of targetCollections) {
+		const fields = await registry.listFields(collection.id);
+		const portableTextFields = fields.filter((f) => f.type === "portableText");
+		const stringFields = fields.filter((f) => ["text", "string"].includes(f.type));
+		const mediaFields = fields.filter((f) => ["image", "file"].includes(f.type));
+		if (portableTextFields.length === 0 && stringFields.length === 0 && mediaFields.length === 0) continue;
+		validateIdentifier(collection.slug, "collection slug");
+		const tableName = `ec_${collection.slug}`;
+		try {
+			const rows = await sql`
+				SELECT * FROM ${sql.ref(tableName)}
+				WHERE deleted_at IS NULL
+			`.execute(db);
+			for (const row of rows.rows) {
+				let rowUpdated = false;
+				const updates = {};
+				let rowUrlsRewritten = 0;
+				for (const field of portableTextFields) {
+					const value = row[field.slug];
+					if (!value || typeof value !== "string") continue;
+					try {
+						const blocks = JSON.parse(value);
+						if (!Array.isArray(blocks)) continue;
+						const rewriteResult = rewritePortableTextUrls(blocks, urlMap, baseMap);
+						if (rewriteResult.changed) {
+							updates[field.slug] = JSON.stringify(blocks);
+							rowUpdated = true;
+							rowUrlsRewritten += rewriteResult.urlsRewritten;
+						}
+					} catch {
+						const stringResult = rewriteStringUrls(value, urlMap, baseMap);
+						if (stringResult.changed) {
+							updates[field.slug] = stringResult.newValue;
+							rowUpdated = true;
+							rowUrlsRewritten += stringResult.urlsRewritten;
+						}
+					}
+				}
+				for (const field of stringFields) {
+					const value = row[field.slug];
+					if (!value || typeof value !== "string") continue;
+					const stringResult = rewriteStringUrls(value, urlMap, baseMap);
+					if (stringResult.changed) {
+						updates[field.slug] = stringResult.newValue;
+						rowUpdated = true;
+						rowUrlsRewritten += stringResult.urlsRewritten;
+					}
+				}
+				for (const field of mediaFields) {
+					const value = row[field.slug];
+					if (!value || typeof value !== "string") continue;
+					const newUrl = findMatchingUrl(value, urlMap, baseMap);
+					if (newUrl) {
+						try {
+							const normalized = await normalizeMediaValue(newUrl, getProvider);
+							updates[field.slug] = normalized ? JSON.stringify(normalized) : newUrl;
+						} catch {
+							updates[field.slug] = newUrl;
+						}
+						rowUpdated = true;
+						rowUrlsRewritten++;
+					}
+				}
+				if (rowUpdated) try {
+					let query = db.updateTable(tableName).where("id", "=", row.id);
+					for (const [key, value] of Object.entries(updates)) query = query.set({ [key]: value });
+					await query.execute();
+					result.updated++;
+					result.urlsRewritten += rowUrlsRewritten;
+					result.byCollection[collection.slug] = (result.byCollection[collection.slug] || 0) + 1;
+				} catch (updateError) {
+					result.errors.push({
+						collection: collection.slug,
+						id: row.id,
+						error: updateError instanceof Error ? updateError.message : "Update failed"
+					});
+				}
+			}
+		} catch (queryError) {
+			result.errors.push({
+				collection: collection.slug,
+				id: "*",
+				error: queryError instanceof Error ? queryError.message : "Query failed for collection"
+			});
+		}
+	}
+	return result;
+}
+
+//#endregion
+export { POST, prerender };

package/dist/astro/routes/api/import/wordpress-plugin/analyze.d.mts

@@ -0,0 +1,15 @@
+import { o as ImportAnalysis } from "../../../../../types-C982qI5I.mjs";
+import { APIRoute } from "astro";
+
+//#region src/astro/routes/api/import/wordpress-plugin/analyze.d.ts
+declare const prerender = false;
+interface WpPluginAnalyzeResponse {
+  success: boolean;
+  analysis?: ImportAnalysis;
+  error?: {
+    message: string;
+  };
+}
+declare const POST: APIRoute;
+//#endregion
+export { POST, WpPluginAnalyzeResponse, prerender };

package/dist/astro/routes/api/import/wordpress-plugin/analyze.mjs

@@ -0,0 +1,69 @@
+import "../../../../../base64-Cz-aU0X1.mjs";
+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 { r as wpPluginAnalyzeBody } from "../../../../../import-DD3f2jkc.mjs";
+import "../../../../../api/schemas/index.mjs";
+import { s as getSource } from "../../../../../import-DVZcYlDp.mjs";
+import { n as resolveAndValidateExternalUrl, t as SsrfError } from "../../../../../ssrf-CmM76lLV.mjs";
+import "../../../../../utils-D2in-zwy.mjs";
+import { n as requirePerm } from "../../../../../authorize-BBj8C6Y8.mjs";
+import { SchemaRegistry } from "dineway";
+
+//#region src/astro/routes/api/import/wordpress-plugin/analyze.ts
+const prerender = false;
+const POST = async ({ request, locals }) => {
+	const { dineway, user } = locals;
+	const denied = requirePerm(user, "import:execute");
+	if (denied) return denied;
+	try {
+		const body = await parseBody(request, wpPluginAnalyzeBody);
+		if (isParseError(body)) return body;
+		try {
+			await resolveAndValidateExternalUrl(body.url);
+		} catch (e) {
+			return apiError("SSRF_BLOCKED", e instanceof SsrfError ? e.message : "Invalid URL", 400);
+		}
+		const source = getSource("wordpress-plugin");
+		if (!source) return apiError("NOT_CONFIGURED", "WordPress plugin source not available", 500);
+		const existingCollections = await fetchExistingCollections(dineway?.db);
+		return apiSuccess({
+			success: true,
+			analysis: await source.analyze({
+				type: "url",
+				url: body.url,
+				token: body.token
+			}, {
+				db: dineway?.db,
+				getExistingCollections: async () => existingCollections
+			})
+		});
+	} catch (error) {
+		return handleError(error, "Failed to analyze WordPress site", "WP_PLUGIN_ANALYZE_ERROR");
+	}
+};
+/** Fetch collections and their fields from schema registry */
+async function fetchExistingCollections(db) {
+	const result = /* @__PURE__ */ new Map();
+	if (!db) return result;
+	try {
+		const registry = new SchemaRegistry(db);
+		const collections = await registry.listCollections();
+		for (const collection of collections) {
+			const fields = await registry.listFields(collection.id);
+			const fieldMap = /* @__PURE__ */ new Map();
+			for (const field of fields) fieldMap.set(field.slug, { type: field.type });
+			result.set(collection.slug, {
+				slug: collection.slug,
+				fields: fieldMap
+			});
+		}
+	} catch (error) {
+		console.warn("Could not fetch schema registry:", error);
+	}
+	return result;
+}
+
+//#endregion
+export { POST, prerender };

package/dist/astro/routes/api/import/wordpress-plugin/callback.d.mts

@@ -0,0 +1,7 @@
+import { APIRoute } from "astro";
+
+//#region src/astro/routes/api/import/wordpress-plugin/callback.d.ts
+declare const prerender = false;
+declare const GET: APIRoute;
+//#endregion
+export { GET, prerender };

package/dist/astro/routes/api/import/wordpress-plugin/callback.mjs

@@ -0,0 +1,28 @@
+import { r as encodeBase64 } from "../../../../../base64-Cz-aU0X1.mjs";
+
+//#region src/astro/routes/api/import/wordpress-plugin/callback.ts
+const prerender = false;
+const GET = async ({ url, cookies, redirect }) => {
+	const siteUrl = url.searchParams.get("site_url");
+	const userLogin = url.searchParams.get("user_login");
+	const password = url.searchParams.get("password");
+	if (!siteUrl || !userLogin || !password) return redirect("/_dineway/admin/import/wordpress?error=auth_rejected");
+	const token = encodeBase64(`${userLogin}:${password}`);
+	const encodedAuth = encodeBase64(JSON.stringify({
+		siteUrl,
+		userLogin,
+		token,
+		timestamp: Date.now()
+	}));
+	cookies.set("dineway_wp_auth", encodedAuth, {
+		path: "/_dineway/",
+		maxAge: 300,
+		httpOnly: false,
+		secure: url.protocol === "https:",
+		sameSite: "lax"
+	});
+	return redirect("/_dineway/admin/import/wordpress?auth=success");
+};
+
+//#endregion
+export { GET, prerender };

package/dist/astro/routes/api/import/wordpress-plugin/execute.d.mts

@@ -0,0 +1,19 @@
+import { s as ImportConfig, u as ImportResult } from "../../../../../types-C982qI5I.mjs";
+import { APIRoute } from "astro";
+
+//#region src/astro/routes/api/import/wordpress-plugin/execute.d.ts
+declare const prerender = false;
+interface WpPluginImportConfig extends ImportConfig {
+  /** Author mappings (WP author login -> Dineway user ID) */
+  authorMappings?: Record<string, string | null>;
+}
+interface WpPluginImportResponse {
+  success: boolean;
+  result?: ImportResult;
+  error?: {
+    message: string;
+  };
+}
+declare const POST: APIRoute;
+//#endregion
+export { POST, WpPluginImportConfig, WpPluginImportResponse, prerender };