@fluid-app/fluid-cli-localization 0.1.5 → 0.1.7

package/dist/index.mjs

@@ -628,6 +628,433 @@ function complianceView(countryCode, atlas) {
 	};
 }
 //#endregion
+//#region src/countries/forms.ts
+const FORMS_PATH = "/api/forms";
+const PER_PAGE$2 = 100;
+const MAX_PAGES$3 = 200;
+/** The title of the enrollment form the atlas seeds for a country, the same
+*  title the admin gives it. */
+const enrollmentFormTitle = (countryName) => `Enrollment - ${countryName}`;
+/** The member types an atlas field can be required for. */
+const AUDIENCES = [
+	"rep",
+	"preferred",
+	"customer"
+];
+/**
+* Each atlas `component` (a form-builder component name) and the element it
+* is stored as. Identity fields are `input` elements named by `puck_type`.
+*/
+const COMPONENT_MAPPINGS = {
+	LegalName: {
+		element_type: "input",
+		puck_type: "legal_name",
+		text: true
+	},
+	FullName: {
+		element_type: "input",
+		puck_type: "full_name",
+		text: true
+	},
+	Email: {
+		element_type: "input",
+		puck_type: "email",
+		text: true
+	},
+	PhoneNumber: {
+		element_type: "input",
+		puck_type: "phone_number",
+		text: true
+	},
+	DateOfBirth: {
+		element_type: "input",
+		puck_type: "date_of_birth",
+		sensitive: true
+	},
+	ShortTextEntry: {
+		element_type: "short_text_entry",
+		puck_type: "short_text_entry",
+		text: true
+	},
+	LongTextEntry: {
+		element_type: "long_text_entry",
+		puck_type: "long_text_entry",
+		text: true
+	},
+	NumberEntry: {
+		element_type: "number_entry",
+		puck_type: "number_entry",
+		text: true
+	},
+	YesNo: {
+		element_type: "yes_no_entry",
+		puck_type: "yes_no_entry"
+	},
+	MultipleChoice: {
+		element_type: "multiple_choice_entry",
+		puck_type: "multiple_choice_entry"
+	},
+	FileUpload: {
+		element_type: "file_upload",
+		puck_type: "file_upload"
+	},
+	Checkbox: {
+		element_type: "checkbox",
+		puck_type: "checkbox"
+	}
+};
+/** Components an enrollment form must not collect. The repository's review
+*  rules treat a form that collects SSNs as critical, so the admin never
+*  seeds one either. */
+const EXCLUDED_COMPONENTS = new Set(["SocialSecurityNumber"]);
+/** Identity components: a form with any one of them covers the atlas field,
+*  whatever its label. Other components match by label. */
+const IDENTITY_PUCK_TYPES = new Set([
+	"legal_name",
+	"full_name",
+	"email",
+	"phone_number",
+	"date_of_birth",
+	"ssn"
+]);
+/** The element types an existing component may be stored as, older names
+*  included, each mapped to the `puck_type` this module compares. */
+const STORED_TYPE_ALIASES = {
+	legal_name: "legal_name",
+	full_name: "full_name",
+	email: "email",
+	phone_number: "phone_number",
+	date_of_birth: "date_of_birth",
+	ssn: "ssn",
+	short_text_entry: "short_text_entry",
+	text: "short_text_entry",
+	long_text_entry: "long_text_entry",
+	number_entry: "number_entry",
+	number: "number_entry",
+	yes_no_entry: "yes_no_entry",
+	yes_no: "yes_no_entry",
+	multiple_choice_entry: "multiple_choice_entry",
+	multiple_choice: "multiple_choice_entry",
+	file_upload: "file_upload",
+	checkbox: "checkbox"
+};
+/**
+* Labels of data an enrollment form must not collect: SSNs, national and tax
+* ID numbers, bank and card details, and passwords. The repository's review
+* rules treat a form that collects any of them as critical, and the atlas
+* names them in the label (a `ShortTextEntry` labelled "CPF" or "IBAN"), not
+* in the component, so the label is checked too, on every component that
+* takes a value: a respondent types what the label asks for, whatever the
+* element type. A false match only leaves a field to a person.
+*/
+const RESTRICTED_DATA_LABEL = /\b(SSN|EIN|ITIN|CPF|CNPJ|CURP|RFC|RUC|RUT|NIT|NIF|NIE|NIP|TIN|TPIN|PAN|INN|OIB|CUIT|CUIL|NPWP|IRD|UTR|KRA|IBAN|SWIFT|BIC|CVV|CVC|VAT|GST|GSTIN|ABN|TRN|NTN)\b|tax|fiscal|steuer|social security|national (id|identity|insurance)|identity (number|card|document)|government id|passport|personnummer|id number|bank|routing|sort code|account number|e-?wallet|card number|credit card|debit card|password|passcode/i;
+/** Components whose answer is yes or no, so they collect no number
+*  whatever their label says: a yes/no about tax registration is fine. Every
+*  other component takes a value, and its label decides. */
+const BOOLEAN_COMPONENTS = new Set(["YesNo", "Checkbox"]);
+/** Whether an atlas field asks for data an enrollment form must not
+*  collect, by component or by label. */
+function collectsRestrictedData(field) {
+	return EXCLUDED_COMPONENTS.has(field.component) || !BOOLEAN_COMPONENTS.has(field.component) && RESTRICTED_DATA_LABEL.test(field.label ?? "");
+}
+/** The choices of a MultipleChoice field: strings or `{ label }`. */
+function choicesOf(field) {
+	const options = field["options"];
+	if (!Array.isArray(options)) return [];
+	return options.flatMap((choice) => {
+		const label = typeof choice === "string" ? choice : choice?.label;
+		return typeof label === "string" && label.trim() ? [label.trim()] : [];
+	});
+}
+/** Whether every member type gets the field. A Post Purchase form is chosen
+*  by country only, so a field for some member types would reach everyone. */
+function forEveryone(field) {
+	const audiences = field.requiredFor ?? [];
+	return audiences.length === 0 || AUDIENCES.every((a) => audiences.includes(a));
+}
+/** Each atlas enrollment field, in atlas order, with the element it maps to
+*  and whether the command may create it. */
+function mapAtlasFields(fields) {
+	return fields.map((field, index) => ({
+		field,
+		index
+	})).filter(({ field }) => Boolean(field.label?.trim())).sort((a, b) => {
+		const oa = a.field.order ?? Number.POSITIVE_INFINITY;
+		const ob = b.field.order ?? Number.POSITIVE_INFINITY;
+		return oa === ob ? a.index - b.index : oa - ob;
+	}).map(({ field, index }) => {
+		const mapping = COMPONENT_MAPPINGS[field.component];
+		const options = field.component === "MultipleChoice" ? choicesOf(field) : [];
+		const excluded = collectsRestrictedData(field) ? "notCollected" : !forEveryone(field) ? "someMemberTypes" : !mapping || field.component === "MultipleChoice" && options.length === 0 ? "needsFormBuilder" : null;
+		return {
+			id: field.id ?? `field-${index}`,
+			label: field.label.trim(),
+			component: field.component,
+			required: field.required === true,
+			order: field.order ?? index,
+			requiredFor: field.requiredFor ?? [],
+			elementType: mapping?.element_type ?? null,
+			puckType: mapping?.puck_type ?? null,
+			sensitive: mapping?.sensitive === true,
+			excluded,
+			options
+		};
+	});
+}
+const EXCLUSION_REASONS = {
+	notCollected: "Enrollment forms must not collect SSNs, national or tax ID numbers, bank or card details, or passwords. Collect it outside Fluid's forms, e.g. through your tax or payout provider.",
+	someMemberTypes: "The atlas asks only some member types for it, and a Post Purchase form reaches everyone who enrolls in the country. Collect it where you can limit it to those member types.",
+	needsFormBuilder: "The atlas doesn't give enough to build it (a multiple choice with no choices, or a component the form builder doesn't have). Add it in the form builder."
+};
+/** The component for an atlas field, as the form builder would save it. */
+function componentFor(field) {
+	const mapping = COMPONENT_MAPPINGS[field.component];
+	if (!mapping || field.excluded) throw new LocalizationError(`Atlas field ${field.id} (${field.component}) isn't one this command creates.`);
+	return {
+		element_type: mapping.element_type,
+		puck_type: mapping.puck_type,
+		label: field.label,
+		placeholder: "",
+		field_data_value: "",
+		required: field.required,
+		...mapping.text ? { case_sensitive: false } : {},
+		sensitive_info: field.sensitive,
+		auto_translate: true,
+		translations: [],
+		show_label: true,
+		is_form_field: true,
+		...field.component === "MultipleChoice" ? { multiple_choice_options: field.options.map((label, index) => ({
+			label,
+			id: String(index)
+		})) } : {},
+		...field.component === "YesNo" ? { yes_no_options: [{
+			label: "Yes",
+			value: "yes"
+		}, {
+			label: "No",
+			value: "no"
+		}] } : {}
+	};
+}
+const normalizeLabel = (label) => typeof label === "string" ? label.trim().replace(/\s+/g, " ").toLowerCase() : "";
+/** The `puck_type` an existing component compares as, older types included. */
+function storedType(component) {
+	return STORED_TYPE_ALIASES[(typeof component.puck_type === "string" && component.puck_type ? component.puck_type : component.element_type ?? "").toLowerCase()] ?? null;
+}
+/** Whether a component already collects an atlas field: the same identity
+*  field, or the same kind of field with the same label. */
+function componentCovers(component, field) {
+	if (!field.puckType) return false;
+	const type = storedType(component);
+	if (type !== field.puckType) return false;
+	if (IDENTITY_PUCK_TYPES.has(type)) return true;
+	return normalizeLabel(component.label) === normalizeLabel(field.label);
+}
+/** A form's components, parsed. Ids are the stored elements' ids. */
+function componentsOf(form) {
+	const raw = form.form_components;
+	if (raw == null || raw === "") return [];
+	let parsed;
+	try {
+		parsed = typeof raw === "string" ? JSON.parse(raw) : raw;
+	} catch {
+		throw new LocalizationError(`Form ${form.id} ("${form.title}") has components that aren't valid JSON, so it can't be read safely. Fix it in the form builder.`);
+	}
+	return Array.isArray(parsed) ? parsed.filter((c) => c && typeof c === "object") : [];
+}
+/** GET /api/forms, every page. */
+async function listForms(client) {
+	const forms = [];
+	for (let page = 1; page <= MAX_PAGES$3; page += 1) {
+		const body = await client.get(FORMS_PATH, {
+			page,
+			per_page: PER_PAGE$2
+		});
+		const batch = body.data ?? [];
+		forms.push(...batch);
+		const next = body.pagination?.next_page;
+		const total = body.pagination?.total_pages ?? 1;
+		if (batch.length === 0 || next == null && page >= total) return forms;
+	}
+	throw new LocalizationError(`The company has more than ${MAX_PAGES$3 * PER_PAGE$2} forms, more than one run reads.`);
+}
+/** GET /api/forms/:id, read again just before it's changed. */
+async function getForm(client, id) {
+	const body = await client.get(`${FORMS_PATH}/${id}`);
+	const form = "form" in body && body.form ? body.form : body;
+	if (typeof form?.id !== "number") throw new LocalizationError(`Form ${id} couldn't be read.`);
+	return form;
+}
+const isPostPurchase = (form) => form.form_type === "post_purchase";
+const isActive = (form) => form.status === "active";
+const countryIdsOf = (form) => (form.countries ?? []).map((c) => c.id);
+/**
+* The form --create writes to: the form named with --form, else the
+* country's atlas form (titled `Enrollment - <Country>`, Post Purchase,
+* scoped to this country alone), active before draft. A form shared with
+* other countries is never a target: a field one country's atlas asks for
+* doesn't belong on another country's enrollment.
+*/
+function targetForm(forms, country, formId) {
+	const own = (form) => {
+		const ids = countryIdsOf(form);
+		return ids.length === 1 && ids[0] === country.id;
+	};
+	if (formId !== void 0) {
+		const form = forms.find((f) => f.id === formId);
+		if (!form) throw new LocalizationError(`The company has no form ${formId}.`);
+		if (!isPostPurchase(form)) throw new LocalizationError(`Form ${formId} ("${form.title}") is a ${form.form_type ?? "untyped"} form, not Post Purchase, so enrollment checkout doesn't show it.`);
+		if (!own(form)) throw new LocalizationError(`Form ${formId} ("${form.title}") isn't scoped to ${country.name} alone, so this command won't add country fields to it. Pick a form for ${country.name} only, or leave out --form to use or create "${enrollmentFormTitle(country.name)}".`);
+		return form;
+	}
+	const title = enrollmentFormTitle(country.name);
+	const candidates = forms.filter((f) => isPostPurchase(f) && own(f) && f.title === title);
+	return candidates.find(isActive) ?? [...candidates].sort((a, b) => (b.updated_at ?? "").localeCompare(a.updated_at ?? ""))[0] ?? null;
+}
+/** What the forms say about a country's atlas enrollment fields, and what
+*  --create would send. */
+function formsReport(input) {
+	const { countryCode, country, atlas, options = {} } = input;
+	const fields = mapAtlasFields(atlas.enrollmentFormFields ?? []);
+	const forCountry = input.forms.filter((f) => isPostPurchase(f) && countryIdsOf(f).includes(country.id));
+	const target = targetForm(input.forms, country, options.formId);
+	const parsed = new Map(forCountry.map((f) => [f.id, componentsOf(f)]));
+	if (target && !parsed.has(target.id)) parsed.set(target.id, componentsOf(target));
+	const covers = (formId, field) => (parsed.get(formId) ?? []).some((c) => componentCovers(c, field));
+	const active = forCountry.filter(isActive);
+	const rows = fields.map((field) => {
+		const collectedBy = active.filter((f) => covers(f.id, field)).map((f) => f.id);
+		const { options: _options, excluded, ...rest } = field;
+		const state = excluded ? "byHand" : collectedBy.length > 0 ? "collected" : target && covers(target.id, field) ? "inDraft" : "missing";
+		return {
+			...rest,
+			state,
+			collectedBy,
+			...excluded ? { reason: EXCLUSION_REASONS[excluded] } : {}
+		};
+	});
+	const missing = rows.filter((r) => r.state === "missing");
+	const toAdd = fields.filter((f) => missing.some((m) => m.id === f.id && !(options.skipSensitive && f.sensitive)));
+	const skippedSensitive = options.skipSensitive ? missing.filter((m) => m.sensitive).map((m) => m.id) : [];
+	const title = target?.title ?? enrollmentFormTitle(country.name);
+	const wantsActivate = options.activate === true && (target ? !isActive(target) : true);
+	const action = toAdd.length > 0 ? target ? "update" : "create" : target && wantsActivate ? "update" : "none";
+	const activate = action !== "none" && wantsActivate;
+	const plan = {
+		action,
+		formId: target?.id ?? null,
+		title,
+		status: (target ? isActive(target) : false) || options.activate ? "active" : "draft",
+		add: toAdd.map((f) => ({
+			id: f.id,
+			label: f.label,
+			elementType: f.elementType,
+			puckType: f.puckType,
+			required: f.required,
+			sensitive: f.sensitive
+		})),
+		skippedSensitive,
+		activate
+	};
+	const report = {
+		country: countryCode,
+		countryId: country.id,
+		countryName: country.name,
+		done: missing.length === 0 && rows.every((r) => r.state !== "inDraft"),
+		forms: forCountry.map((f) => ({
+			id: f.id,
+			title: f.title,
+			status: f.status ?? null,
+			countries: (f.countries ?? []).map((c) => c.iso ?? String(c.id)),
+			shared: countryIdsOf(f).length > 1,
+			atlasFields: fields.filter((field) => covers(f.id, field)).map((x) => x.id),
+			components: parsed.get(f.id)?.length ?? 0
+		})),
+		target: target ? {
+			id: target.id,
+			title: target.title,
+			status: target.status ?? null
+		} : null,
+		fields: rows,
+		missing: missing.map((m) => m.id),
+		plan
+	};
+	if (fields.length === 0) {
+		report.note = `The atlas lists no enrollment fields for ${countryCode}, so there is nothing to add.`;
+		return report;
+	}
+	if (report.forms.some((f) => f.shared)) report.note = `Forms shared with other countries are read, not changed. A field they lack goes on ${countryCode}'s own form, which enrollment shows beside them.`;
+	const draftOnly = rows.filter((r) => r.state === "inDraft");
+	if (draftOnly.length > 0 && target && !isActive(target)) report.draft = `"${target.title}" (${target.id}) is a draft, so enrollment doesn't ask for ${draftOnly.map((r) => r.id).join(", ")} yet. Review it in the form builder and publish it, or rerun with --create --activate --yes.`;
+	if (action !== "none") report.next = `fluid countries forms ${countryCode} --create${options.formId !== void 0 ? ` --form ${options.formId}` : ""}${options.activate ? " --activate" : ""}${options.skipSensitive ? " --skip-sensitive" : ""} --yes`;
+	return report;
+}
+/** The message the forms API answers when the caller can't change which
+*  fields are sensitive. */
+const SENSITIVE_DENIED = /permission to change which fields are marked sensitive/i;
+/** Turn the forms API's sensitive-permission 422 into an actionable error. */
+function explainSensitiveDenial(error, fields) {
+	if (statusOf(error) === 422 && SENSITIVE_DENIED.test(errorDetail(error).message)) throw Object.assign(new LocalizationError(`Your token can't create fields marked sensitive (${fields.join(", ")}): that needs the forms manage-sensitive permission. Nothing was saved. Run it with a token whose role has that permission, or rerun with --skip-sensitive to create the rest and leave those fields to someone who has it.`), { status: 422 });
+	throw error;
+}
+/**
+* Apply a plan. A new form is created with the fields. An existing form is
+* read again first and every one of its components is sent back as it is,
+* ids included, with the new ones after them, so nothing on it is
+* deactivated and no field's sensitivity changes; fields an admin added since
+* the preview aren't added twice.
+*/
+async function applyFormsPlan(client, report, fields) {
+	const { plan } = report;
+	const byId = new Map(fields.map((f) => [f.id, f]));
+	const toAdd = plan.add.map((a) => byId.get(a.id));
+	const sensitive = toAdd.filter((f) => f.sensitive).map((f) => f.id);
+	const result = (action, form, added, activated) => ({
+		action,
+		form: form ? {
+			id: form.id,
+			title: form.title,
+			status: form.status ?? null
+		} : null,
+		added,
+		activated,
+		skippedSensitive: plan.skippedSensitive
+	});
+	if (plan.action === "none") return result("none", null, [], false);
+	if (plan.action === "create") {
+		let body;
+		try {
+			body = await client.post(FORMS_PATH, { form: {
+				title: plan.title,
+				form_type: "post_purchase",
+				status: plan.status,
+				form_redirect: "",
+				country_ids: [report.countryId],
+				form_components: JSON.stringify(toAdd.map(componentFor))
+			} });
+		} catch (error) {
+			explainSensitiveDenial(error, sensitive);
+		}
+		return result("created", body.form ?? null, toAdd.map((f) => f.id), plan.status === "active");
+	}
+	const current = await getForm(client, plan.formId);
+	const existing = componentsOf(current);
+	const stillMissing = toAdd.filter((f) => !existing.some((c) => componentCovers(c, f)));
+	if (stillMissing.length === 0 && !plan.activate) return result("none", current, [], false);
+	const unidentified = existing.filter((c) => c.id == null || c.id === "");
+	if (stillMissing.length > 0 && unidentified.length > 0) throw new LocalizationError(`Form ${current.id} ("${current.title}") has ${unidentified.length} component(s) without an element id, so sending its components back could deactivate them. Open it in the form builder and save it once, then rerun.`);
+	let body;
+	try {
+		body = await client.put(`${FORMS_PATH}/${current.id}`, { form: {
+			...stillMissing.length > 0 ? { form_components: JSON.stringify([...existing, ...stillMissing.map(componentFor)]) } : {},
+			...plan.activate ? { status: "active" } : {}
+		} });
+	} catch (error) {
+		explainSensitiveDenial(error, stillMissing.filter((f) => f.sensitive).map((f) => f.id));
+	}
+	return result("updated", body.form ?? current, stillMissing.map((f) => f.id), plan.activate);
+}
+//#endregion
 //#region src/countries/prices.ts
 /** The money fields a conversion can write, as the variants API names them. */
 const PRICE_FIELDS = [
@@ -1222,9 +1649,20 @@ function statusReport(input) {
 		ok: input.prices.onSale > 0 || input.prices.bundles.length > 0,
 		detail: input.prices.onSale > 0 ? `${input.prices.onSale} variants are on sale in ${countryCode}.` : input.prices.bundles.length > 0 ? `No single products are on sale in ${countryCode}; check the bundles under byHand.bundles.` : `Nothing is on sale in ${countryCode} yet. Turn on the products you'll sell there, or run prices with --activate.`
 	}] : [];
+	const enrollment = input.enrollment && !("unavailable" in input.enrollment) ? input.enrollment : null;
+	const enrollmentChecks = enrollment ? [{
+		id: "enrollment_form",
+		ok: enrollment.done,
+		detail: enrollment.done ? enrollment.fields.length === 0 ? `The atlas lists no enrollment fields for ${countryCode}.` : `Enrollment in ${countryCode} asks for every atlas field a Post Purchase form can collect.` : enrollment.missing.length > 0 ? `Enrollment in ${countryCode} doesn't ask for ${enrollment.missing.join(", ")}. Run \`fluid countries forms ${countryCode}\`.` : enrollment.draft ?? `The enrollment form for ${countryCode} isn't published.`
+	}] : input.enrollment && "unavailable" in input.enrollment ? [{
+		id: "enrollment_form",
+		ok: false,
+		detail: `Couldn't read the company's forms (${input.enrollment.unavailable}), so the enrollment fields weren't checked.`
+	}] : [];
 	const checks = [
 		...settingsChecks(atlas, cc),
 		...priceChecks,
+		...enrollmentChecks,
 		...languages.map((l) => ({
 			id: `language:${l.iso}`,
 			ok: l.enabled,
@@ -1249,6 +1687,10 @@ function statusReport(input) {
 			report: `fluid translations missing ${iso}`,
 			translate: `fluid translations auto ${iso} --write --yes`
 		})),
+		enrollmentForm: {
+			report: `fluid countries forms ${countryCode}`,
+			create: `fluid countries forms ${countryCode} --create --yes`
+		},
 		prices: {
 			preview: `fluid countries prices ${countryCode}`,
 			convert: `fluid countries prices ${countryCode} --rate <rate> --write --yes`
@@ -1263,7 +1705,13 @@ function statusReport(input) {
 				name: m.name,
 				recommended: m.enabled
 			})),
-			enrollmentFields: [...atlas.enrollmentFormFields ?? []].sort((a, b) => a.order - b.order).map((f) => ({
+			enrollmentFields: enrollment ? enrollment.fields.filter((f) => f.state === "byHand").map((f) => ({
+				id: f.id,
+				label: f.label,
+				component: f.component,
+				required: f.required,
+				...f.reason ? { reason: f.reason } : {}
+			})) : [...atlas.enrollmentFormFields ?? []].sort((a, b) => a.order - b.order).map((f) => ({
 				id: f.id,
 				label: f.label,
 				component: f.component,
@@ -3324,6 +3772,20 @@ async function withTranslationGaps(api, atlas, states) {
 async function countryPriceCoverage(api, iso) {
 	return priceCoverage(await listProductsWithVariants(api, ["active"]), iso);
 }
+/** The country's enrollment form report, or the reason it couldn't be
+*  read (a token without forms access), so status still runs. */
+async function countryEnrollment(api, countryCode, atlas) {
+	try {
+		return formsReport({
+			countryCode,
+			country: await catalogCountry(api, countryCode),
+			atlas,
+			forms: await listForms(api)
+		});
+	} catch (error) {
+		return { unavailable: failureOf(error).error };
+	}
+}
 function registerCountriesCommands(parent, ctx) {
 	parent.command("atlas <iso>").description("Show Fluid's Country Atlas for a market: modes, tax, legal, address, payments, languages, agreements").option("--agreement <localId>", "Print one atlas agreement's full text in every language instead").action((iso, opts) => run(async () => {
 		const result = await fetchAtlas(await client$1(ctx), iso);
@@ -3532,6 +3994,46 @@ function registerCountriesCommands(parent, ctx) {
 		});
 		if (failed.length > 0 || created.some((c) => c.failedTranslations.length > 0)) process.exitCode = 1;
 	}));
+	parent.command("forms <iso>").description("Compare the atlas enrollment fields with the country's Post Purchase forms; --create sets up its enrollment form, as a draft unless --activate (changes live config)").option("--create", "Create the country's enrollment form, or add the missing atlas fields to it", false).option("--form <id>", "With --create, add to this Post Purchase form for the country instead").option("--activate", "With --create, publish the form so enrollment asks for its fields now", false).option("--skip-sensitive", "With --create, leave out fields stored as sensitive, which need the forms manage-sensitive permission", false).option("--yes", "Confirm without a prompt", false).action((iso, opts) => run(async () => {
+		if (!opts.create && (opts.form || opts.activate || opts.skipSensitive)) throw new LocalizationError("--form, --activate and --skip-sensitive go with --create.");
+		const api = await client$1(ctx);
+		const { countryCode, atlas } = await requireAtlas(api, iso);
+		const country = await catalogCountry(api, countryCode);
+		const options = {
+			...opts.form ? { formId: positiveInt(opts.form, "--form") } : {},
+			activate: opts.activate,
+			skipSensitive: opts.skipSensitive
+		};
+		const report = formsReport({
+			countryCode,
+			country,
+			atlas,
+			forms: await listForms(api),
+			options
+		});
+		if (!opts.create || report.plan.action === "none") {
+			ctx.output({
+				...report,
+				written: false
+			});
+			return;
+		}
+		const { plan } = report;
+		await confirmChange(`${plan.action === "create" ? `Create "${plan.title}" as a ${plan.status} Post Purchase form for ${countryCode}` : `Change form ${plan.formId} ("${plan.title}")`} ${[...plan.add.length > 0 ? [`with ${plan.add.length} field(s): ${plan.add.map((f) => `"${f.label}"${f.sensitive ? " (sensitive)" : ""}`).join(", ")}`] : [], ...plan.action === "update" && plan.activate ? ["and publish it, so enrollment asks for its fields"] : []].join(" ")}?`, opts.yes);
+		const result = await applyFormsPlan(api, report, mapAtlasFields(atlas.enrollmentFormFields ?? []));
+		const after = formsReport({
+			countryCode,
+			country,
+			atlas,
+			forms: await listForms(api),
+			...options.formId !== void 0 ? { options: { formId: options.formId } } : {}
+		});
+		ctx.output({
+			...after,
+			written: result.action !== "none",
+			...result
+		});
+	}));
 	parent.command("prices <iso>").description("Convert every variant's price from another country into this one's currency at an exchange rate. A dry run unless --write (changes live prices)").option("--from-country <iso>", "The country whose prices are converted", "US").option("--rate <rate>", "Units of the new currency per unit of the source currency, e.g. 0.92; --write needs it").option("--fields <list>", `Price fields to convert, comma-separated, from ${PRICE_FIELDS.join(", ")}`, DEFAULT_PRICE_FIELDS.join(",")).option("--status <status>", "Product status to include (repeatable)", collect, []).option("--overwrite", "Also replace prices the country already has", false).option("--activate", "Put each converted variant on sale in the country", false).option("--sample <n>", "How many before→after examples to print", "10").option("--write", "Save the converted prices; without it nothing is written", false).option("--yes", "Confirm --write without a prompt", false).action((iso, opts) => run(async () => {
 		const api = await client$1(ctx);
 		const targetIso = countryCodeOf(iso);
@@ -3643,13 +4145,15 @@ function registerCountriesCommands(parent, ctx) {
 		const { countryCode, atlas } = await requireAtlas(api, iso);
 		const cc = await findCompanyCountry(api, countryCode);
 		const [languages, agreements] = cc ? await Promise.all([listLanguages(api), listAgreements(api)]) : [[], []];
+		const enrollment = cc ? await countryEnrollment(api, countryCode, atlas) : void 0;
 		ctx.output(statusReport({
 			countryCode,
 			atlas,
 			companyCountry: cc,
 			languages: languageStates(atlas, languages),
 			agreements: await withTranslationGaps(api, atlas, agreementStates(atlas, agreements, cc?.id ?? null)),
-			...cc ? { prices: await countryPriceCoverage(api, countryCode) } : {}
+			...cc ? { prices: await countryPriceCoverage(api, countryCode) } : {},
+			...enrollment ? { enrollment } : {}
 		}));
 	}));
 }