dineway 0.1.9 → 0.1.12

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

@@ -0,0 +1,269 @@
+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-MVYe_Uyf.mjs";
+import "../../../../../context-types-C-LwdAxx.mjs";
+import "../../../../../fts-manager-B1pTNEG_.mjs";
+import "../../../../../registry-C-_hxLqa.mjs";
+import "../../../../../loader-PZnPxFLc.mjs";
+import "../../../../../settings-DGtLLSaz.mjs";
+import "../../../../../request-cache-DHMRr2Lf.mjs";
+import "../../../../../query-CsbOywSY.mjs";
+import "../../../../../zod-generator-DBVP8D0P.mjs";
+import "../../../../../schema-BECjUhP8.mjs";
+import { n as apiSuccess, r as handleError, t as apiError } from "../../../../../error-BMUPwxgx.mjs";
+import { n as parseBody, t as isParseError } from "../../../../../parse-C9106ehs.mjs";
+import "../../../../../redirects-lrlmYXVE.mjs";
+import { i as wpPluginExecuteBody } from "../../../../../import-CNcKWTbp.mjs";
+import "../../../../../api/schemas/index.mjs";
+import { s as getSource } from "../../../../../import-BHRLhXAn.mjs";
+import { n as resolveAndValidateExternalUrl, t as SsrfError } from "../../../../../ssrf-DDwRxF6B.mjs";
+import { m as resolveImportByline } from "../../../../../utils-C0ONdBul.mjs";
+import "../../../../../search-DqTHQqtV.mjs";
+import { n as requirePerm } from "../../../../../authorize-BAdbMCwC.mjs";
+import { _ as RiskPolicyEvaluator, p as WordPressImportHitlPayloadBuilder } from "../../../../../site-context-WBxoD99D.mjs";
+import "../../../../../activity-events-B4wp7CrU.mjs";
+import { i as resolveHitlRouteActor, n as hitlRequiredRouteError, t as ensureWorkflowHitlRouteRequest } from "../../../../../hitl-route-helpers-CSit54Ru.mjs";
+import { z } from "zod";
+import { ContentRepository, SchemaRegistry } from "dineway";
+
+//#region src/astro/routes/api/import/wordpress-plugin/execute.ts
+const prerender = false;
+const wpPluginExecuteRouteBody = wpPluginExecuteBody.extend({ hitlRequestId: z.string().min(1).optional() });
+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 body = await parseBody(request, wpPluginExecuteRouteBody);
+		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 config = body.config;
+		const source = getSource("wordpress-plugin");
+		if (!source) return apiError("NOT_CONFIGURED", "WordPress plugin source not available", 500);
+		const postTypes = Object.entries(config.postTypeMappings).filter(([_, mapping]) => mapping.enabled).map(([postType]) => postType);
+		if (postTypes.length === 0) return apiError("VALIDATION_ERROR", "No post types selected for import", 400);
+		console.log("[WP Plugin Import] Starting import for:", body.url);
+		console.log("[WP Plugin Import] Post types:", postTypes);
+		const sourceInput = {
+			type: "url",
+			url: body.url,
+			token: body.token
+		};
+		const actor = resolveHitlRouteActor(locals);
+		const evaluator = new RiskPolicyEvaluator({
+			db: dineway.db,
+			handlers: dineway
+		});
+		let items;
+		if (evaluator.requiresWorkflowHitl(actor.identity)) {
+			const fetchedItems = await collectPluginItems(source.fetchContent(sourceInput, {
+				postTypes,
+				includeDrafts: true
+			}));
+			const action = await new WordPressImportHitlPayloadBuilder().buildPluginExecuteRequest({
+				siteUrl: body.url,
+				config,
+				items: fetchedItems
+			});
+			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));
+			items = fetchedItems;
+		} else items = source.fetchContent(sourceInput, {
+			postTypes,
+			includeDrafts: true
+		});
+		const manifest = await dineway.getManifest();
+		const result = await importContent(items, config, dineway, manifest);
+		console.log("[WP Plugin Import] Import result:", JSON.stringify(result, null, 2));
+		return apiSuccess({
+			success: true,
+			result
+		});
+	} catch (error) {
+		return handleError(error, "Failed to import from WordPress", "WP_PLUGIN_IMPORT_ERROR");
+	}
+};
+/** Fields that should be auto-created if they don't exist */
+const IMPORT_FIELDS = [
+	{
+		slug: "title",
+		label: "Title",
+		type: "string",
+		check: () => true
+	},
+	{
+		slug: "content",
+		label: "Content",
+		type: "portableText",
+		check: () => true
+	},
+	{
+		slug: "excerpt",
+		label: "Excerpt",
+		type: "text",
+		check: (item) => !!item.excerpt
+	},
+	{
+		slug: "featured_image",
+		label: "Featured Image",
+		type: "image",
+		check: (item) => !!item.featuredImage
+	}
+];
+async function importContent(items, config, dineway, manifest) {
+	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();
+	const schemaRegistry = new SchemaRegistry(dineway.db);
+	const ensuredCollections = /* @__PURE__ */ new Set();
+	const translationGroupMap = /* @__PURE__ */ new Map();
+	for await (const item of items) {
+		console.log("[WP Plugin Import] Processing item:", {
+			sourceId: item.sourceId,
+			title: item.title,
+			postType: item.postType,
+			status: item.status,
+			contentBlocks: Array.isArray(item.content) ? item.content.length : 0,
+			featuredImage: item.featuredImage,
+			locale: item.locale,
+			translationGroup: item.translationGroup
+		});
+		const mapping = config.postTypeMappings[item.postType];
+		if (!mapping || !mapping.enabled) {
+			result.skipped++;
+			continue;
+		}
+		const collection = mapping.collection;
+		if (!manifest?.collections[collection]) {
+			result.errors.push({
+				title: item.title || "Untitled",
+				error: `Collection "${collection}" does not exist`
+			});
+			continue;
+		}
+		try {
+			if (!ensuredCollections.has(collection)) {
+				for (const field of IMPORT_FIELDS) if (field.check(item)) {
+					if (!await schemaRegistry.getField(collection, field.slug)) {
+						console.log(`[WP Plugin Import] Creating missing field "${field.slug}" in collection "${collection}"`);
+						try {
+							await schemaRegistry.createField(collection, {
+								slug: field.slug,
+								label: field.label,
+								type: field.type,
+								required: false
+							});
+						} catch (e) {
+							console.log(`[WP Plugin Import] Field "${field.slug}" creation skipped:`, e instanceof Error ? e.message : e);
+						}
+					}
+				}
+				ensuredCollections.add(collection);
+			}
+			const slug = item.slug || slugify(item.title || `post-${item.sourceId}`);
+			if (config.skipExisting) {
+				const existing = await contentRepo.findBySlug(collection, slug, item.locale);
+				if (existing) {
+					if (item.translationGroup) translationGroupMap.set(item.translationGroup, existing.id);
+					result.skipped++;
+					continue;
+				}
+			}
+			const status = mapStatus(item.status);
+			const data = {};
+			data.title = item.title || "Untitled";
+			data.content = item.content;
+			if (item.excerpt) data.excerpt = item.excerpt;
+			if (item.featuredImage) {
+				data.featured_image = item.featuredImage;
+				console.log("[WP Plugin Import] Adding featured_image:", item.featuredImage);
+			}
+			let authorId;
+			if (config.authorMappings && item.author) {
+				const mappedUserId = config.authorMappings[item.author];
+				if (mappedUserId !== void 0 && mappedUserId !== null) authorId = mappedUserId;
+			}
+			const bylineId = await resolveImportByline(item.author, item.author, authorId, bylineRepo, bylineCache);
+			let translationOf;
+			if (item.translationGroup) {
+				const existingGroupItem = translationGroupMap.get(item.translationGroup);
+				if (existingGroupItem) translationOf = existingGroupItem;
+			}
+			const itemDateTime = item.date?.getTime();
+			const createdAt = itemDateTime !== void 0 && !Number.isNaN(itemDateTime) ? item.date.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: item.locale,
+				translationOf,
+				createdAt,
+				publishedAt
+			});
+			if (createResult.success) {
+				result.imported++;
+				result.byCollection[collection] = (result.byCollection[collection] || 0) + 1;
+				if (item.translationGroup && !translationGroupMap.has(item.translationGroup)) {
+					const createdData = createResult.data;
+					if (createdData?.id) translationGroupMap.set(item.translationGroup, createdData.id);
+				}
+			} else result.errors.push({
+				title: item.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 "${item.title || "Untitled"}":`, error);
+			result.errors.push({
+				title: item.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";
+	}
+}
+async function collectPluginItems(items) {
+	const collected = [];
+	for await (const item of items) collected.push(item);
+	return collected;
+}
+
+//#endregion
+export { POST, prerender };

package/dist/astro/routes/api/manifest.d.mts

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

package/dist/astro/routes/api/manifest.mjs

@@ -0,0 +1,50 @@
+import { n as VERSION, t as COMMIT } from "../../../version-D3vDb22n.mjs";
+import { r as handleError } from "../../../error-BMUPwxgx.mjs";
+import { t as getAuthMode } from "../../../mode-DUhxwUhv.mjs";
+import { i as experimentalSiteContextWorkflowsEnabled } from "../../../experimental-workflows-C9X7yblQ.mjs";
+
+//#region src/astro/routes/api/manifest.ts
+const prerender = false;
+const GET = async ({ locals }) => {
+	try {
+		const { dineway } = locals;
+		const manifestSource = dineway ? await dineway.getManifest() : null;
+		const authMode = getAuthMode(dineway?.config);
+		const adminBranding = manifestSource?.admin ?? dineway?.config.admin;
+		let signupEnabled = false;
+		if (dineway?.db && authMode.type === "passkey") try {
+			const { sql } = await import("kysely");
+			const result = await sql`
+				SELECT COUNT(*) as cnt FROM allowed_domains WHERE enabled = 1
+			`.execute(dineway.db);
+			signupEnabled = Number(result.rows[0]?.cnt ?? 0) > 0;
+		} catch {}
+		const manifest = manifestSource ? {
+			...manifestSource,
+			features: {
+				...manifestSource.features,
+				siteContextWorkflows: experimentalSiteContextWorkflowsEnabled()
+			},
+			authMode: authMode.type === "external" ? authMode.providerType : "passkey",
+			signupEnabled,
+			admin: adminBranding
+		} : {
+			version: VERSION,
+			commit: COMMIT,
+			hash: "default",
+			collections: {},
+			plugins: {},
+			features: { siteContextWorkflows: experimentalSiteContextWorkflowsEnabled() },
+			taxonomies: [],
+			authMode: "passkey",
+			signupEnabled,
+			admin: adminBranding
+		};
+		return Response.json({ data: manifest }, { headers: { "Cache-Control": "private, no-store" } });
+	} catch (error) {
+		return handleError(error, "Failed to build manifest", "MANIFEST_BUILD_ERROR");
+	}
+};
+
+//#endregion
+export { GET, prerender };

package/dist/astro/routes/api/mcp.d.mts

@@ -0,0 +1,15 @@
+import { APIRoute } from "astro";
+
+//#region src/astro/routes/api/mcp.d.ts
+declare const prerender = false;
+declare const POST: APIRoute;
+/**
+ * GET — SSE stream. Not used in stateless mode.
+ */
+declare const GET: APIRoute;
+/**
+ * DELETE — Session close. Not used in stateless mode.
+ */
+declare const DELETE: APIRoute;
+//#endregion
+export { DELETE, GET, POST, prerender };