chore: import upstream snapshot with attribution

packages/plugins/forms/tests/client-submit-response.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, it } from "vitest";
+
+import { parseSubmitResponse } from "../src/client/index.js";
+
+describe("parseSubmitResponse", () => {
+	it("unwraps successful plugin API responses from the standard API envelope", () => {
+		expect(
+			parseSubmitResponse({
+				data: {
+					success: true,
+					message: "Thanks",
+					redirect: "/thanks",
+				},
+			}),
+		).toEqual({ success: true, message: "Thanks", redirect: "/thanks" });
+	});
+
+	it("keeps legacy top-level submit responses working", () => {
+		expect(parseSubmitResponse({ success: true, message: "Thanks" })).toEqual({
+			success: true,
+			message: "Thanks",
+		});
+	});
+
+	it("unwraps validation errors returned in the standard API envelope", () => {
+		expect(
+			parseSubmitResponse({
+				data: {
+					errors: [{ field: "email", message: "Email is required" }],
+				},
+			}),
+		).toEqual({ errors: [{ field: "email", message: "Email is required" }] });
+	});
+
+	it("does not recursively unwrap nested envelopes", () => {
+		expect(parseSubmitResponse({ data: { data: { success: true, message: "Nested" } } })).toEqual({
+			data: { success: true, message: "Nested" },
+		});
+	});
+});

packages/plugins/forms/tests/public-definition.test.ts

@@ -0,0 +1,261 @@
+import { describe, expect, it, vi } from "vitest";
+
+import type { PublicFormDefinition } from "../src/public-definition.js";
+import {
+	loadPublicFormDefinition,
+	parsePublicFormDefinitionPayload,
+	parsePublicFormDefinitionResponse,
+} from "../src/public-definition.js";
+
+const activeForm: PublicFormDefinition = {
+	name: "Contact",
+	slug: "contact",
+	pages: [
+		{
+			fields: [
+				{
+					id: "email",
+					type: "email",
+					label: "Email",
+					name: "email",
+					required: true,
+					width: "full",
+				},
+			],
+		},
+	],
+	settings: {
+		spamProtection: "none",
+		submitLabel: "Send",
+	},
+	status: "active",
+	_turnstileSiteKey: null,
+};
+
+function jsonResponse(body: unknown, status = 200): Response {
+	return new Response(JSON.stringify(body), {
+		status,
+		headers: { "Content-Type": "application/json" },
+	});
+}
+
+describe("parsePublicFormDefinitionResponse", () => {
+	it("unwraps public plugin route responses from the standard API envelope", async () => {
+		await expect(
+			parsePublicFormDefinitionResponse(jsonResponse({ data: activeForm })),
+		).resolves.toEqual(activeForm);
+	});
+
+	it("returns null for missing form data", async () => {
+		await expect(
+			parsePublicFormDefinitionResponse(jsonResponse({ data: undefined })),
+		).resolves.toBeNull();
+	});
+
+	it("returns null for inactive forms and failed responses", async () => {
+		await expect(
+			parsePublicFormDefinitionResponse(
+				jsonResponse({ data: { ...activeForm, status: "paused" } }),
+			),
+		).resolves.toBeNull();
+
+		await expect(
+			parsePublicFormDefinitionResponse(jsonResponse({ error: { message: "Not found" } }, 404)),
+		).resolves.toBeNull();
+	});
+
+	it("does not recursively unwrap nested response envelopes", async () => {
+		await expect(
+			parsePublicFormDefinitionResponse(jsonResponse({ data: { data: activeForm } })),
+		).resolves.toBeNull();
+		await expect(
+			parsePublicFormDefinitionResponse(
+				jsonResponse({ data: { success: true, data: activeForm } }),
+			),
+		).resolves.toBeNull();
+	});
+});
+
+describe("parsePublicFormDefinitionPayload", () => {
+	it("unwraps successful handler results with an active form", () => {
+		expect(parsePublicFormDefinitionPayload({ success: true, data: activeForm })).toEqual(
+			activeForm,
+		);
+	});
+
+	it("returns null for missing or inactive handler result data", () => {
+		expect(parsePublicFormDefinitionPayload({ success: true, data: undefined })).toBeNull();
+		expect(
+			parsePublicFormDefinitionPayload({
+				success: true,
+				data: { ...activeForm, status: "paused" },
+			}),
+		).toBeNull();
+	});
+
+	it("returns null for failed handler results", () => {
+		expect(
+			parsePublicFormDefinitionPayload({
+				success: false,
+				error: { code: "NOT_FOUND", message: "Form not found" },
+			}),
+		).toBeNull();
+	});
+
+	it("does not recursively unwrap nested handler result data", () => {
+		expect(
+			parsePublicFormDefinitionPayload({
+				success: true,
+				data: { data: activeForm },
+			}),
+		).toBeNull();
+		expect(
+			parsePublicFormDefinitionPayload({
+				success: true,
+				data: { success: true, data: activeForm },
+			}),
+		).toBeNull();
+	});
+
+	it("returns null for malformed active form data", () => {
+		expect(
+			parsePublicFormDefinitionPayload({
+				success: true,
+				data: { status: "active" },
+			}),
+		).toBeNull();
+		expect(
+			parsePublicFormDefinitionPayload({
+				success: true,
+				data: { ...activeForm, pages: undefined },
+			}),
+		).toBeNull();
+		expect(
+			parsePublicFormDefinitionPayload({
+				success: true,
+				data: { ...activeForm, settings: undefined },
+			}),
+		).toBeNull();
+		expect(
+			parsePublicFormDefinitionPayload({
+				success: true,
+				data: {
+					...activeForm,
+					pages: [{ fields: [{ ...activeForm.pages[0]!.fields[0]!, type: "unknown" }] }],
+				},
+			}),
+		).toBeNull();
+		expect(
+			parsePublicFormDefinitionPayload({
+				success: true,
+				data: {
+					...activeForm,
+					pages: [{ fields: [{ ...activeForm.pages[0]!.fields[0]!, options: {} }] }],
+				},
+			}),
+		).toBeNull();
+	});
+});
+
+describe("loadPublicFormDefinition", () => {
+	it("loads active forms through the internal public plugin route handler", async () => {
+		const handlePublicPluginApiRoute = vi.fn(async () => ({ success: true, data: activeForm }));
+		const fetch = vi.fn(async () => jsonResponse({ data: activeForm }));
+
+		await expect(
+			loadPublicFormDefinition({
+				formId: "contact",
+				baseUrl: new URL("https://example.com/contact"),
+				handlePublicPluginApiRoute,
+				fetch,
+			}),
+		).resolves.toEqual(activeForm);
+
+		expect(handlePublicPluginApiRoute).toHaveBeenCalledWith(
+			"emdash-forms",
+			"POST",
+			"/definition",
+			expect.any(Request),
+		);
+		expect(fetch).not.toHaveBeenCalled();
+	});
+
+	it("treats internal missing or inactive results as definitive", async () => {
+		const handlePublicPluginApiRoute = vi.fn(async () => ({
+			success: false,
+			error: { code: "NOT_FOUND", message: "Form not found" },
+		}));
+		const fetch = vi.fn(async () => jsonResponse({ data: activeForm }));
+
+		await expect(
+			loadPublicFormDefinition({
+				formId: "missing",
+				baseUrl: new URL("https://example.com/contact"),
+				handlePublicPluginApiRoute,
+				fetch,
+			}),
+		).resolves.toBeNull();
+
+		expect(fetch).not.toHaveBeenCalled();
+	});
+
+	it("treats malformed internal results as definitive", async () => {
+		const handlePublicPluginApiRoute = vi.fn(async () => ({
+			success: true,
+			data: { status: "active" },
+		}));
+		const fetch = vi.fn(async () => jsonResponse({ data: activeForm }));
+
+		await expect(
+			loadPublicFormDefinition({
+				formId: "contact",
+				baseUrl: new URL("https://example.com/contact"),
+				handlePublicPluginApiRoute,
+				fetch,
+			}),
+		).resolves.toBeNull();
+
+		expect(fetch).not.toHaveBeenCalled();
+	});
+
+	it("falls back to fetching the public definition route when no handler is available", async () => {
+		const fetch = vi.fn(async () => jsonResponse({ data: activeForm }));
+
+		await expect(
+			loadPublicFormDefinition({
+				formId: "contact",
+				baseUrl: new URL("https://example.com/contact"),
+				fetch,
+			}),
+		).resolves.toEqual(activeForm);
+
+		expect(fetch).toHaveBeenCalledTimes(1);
+	});
+
+	it("does not fall back to fetching when the internal handler throws", async () => {
+		const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+		const handlePublicPluginApiRoute = vi.fn(async () => {
+			throw new Error("dispatcher unavailable");
+		});
+		const fetch = vi.fn(async () => jsonResponse({ data: activeForm }));
+
+		try {
+			await expect(
+				loadPublicFormDefinition({
+					formId: "contact",
+					baseUrl: new URL("https://example.com/contact"),
+					handlePublicPluginApiRoute,
+					fetch,
+				}),
+			).resolves.toBeNull();
+
+			expect(fetch).not.toHaveBeenCalled();
+			expect(warn).toHaveBeenCalledWith(
+				"[emdash-forms] public definition dispatcher failed:",
+				expect.any(Error),
+			);
+		} finally {
+			warn.mockRestore();
+		}
+	});
+});