@getvitops/utils 8.1.0 → 8.2.0-alpha.0

package/dist/crm/index.mjs

@@ -0,0 +1,731 @@
+import { t as identifySubmitter } from "../identity-BoRddTx3.mjs";
+
+//#region src/crm/map.ts
+/**
+* Turning one submission into a provider-neutral `CrmRecord`.
+*
+* Pure, and separate from both executors for the reason `notify/render.ts` is
+* separate from `email.ts`: shaping the data is where the two subtle rules
+* that must not regress live, and pinning them here means a test can assert
+* them without a network.
+*
+* `fieldMap`/`trackingFields` are drop-if-unmapped, not guess-if-unmapped — an
+* unmapped field silently disappearing from the CRM record is the same shape
+* of decision `describeEvent()` makes for `OMIT_FIELDS`: an absent mapping is
+* a stated design choice (the operator hasn't decided this field matters to
+* the CRM yet), never an error.
+*/
+/**
+* Bigin requires `Last_Name`; a form that only asked for a full name or an
+* email needs one derived rather than 400ing on insert.
+*
+* The fallback chain, in order: an explicit last name field → the last space-
+* separated token of a full name → the local part of the email address →
+* refuse, with a stated reason, rather than fabricate a name from nothing.
+* `map.ts` never emits an empty `lastName` for Bigin — `deliverToCrm` reads
+* the refusal and skips the write instead of letting the CRM reject it.
+*/
+function deriveLastName(identity) {
+	if (identity.lastName) return { lastName: identity.lastName };
+	const nameParts = identity.fullName.trim().split(/\s+/);
+	if (nameParts.length > 1) return { lastName: nameParts[nameParts.length - 1] };
+	if (identity.email) {
+		const local = identity.email.split("@")[0];
+		if (local) return { lastName: local };
+	}
+	return { refusal: "Could not derive a last name from the submission (no last-name field, no space in the full name, and no email to fall back to)." };
+}
+function mapExtra(formData, fieldMap) {
+	const out = {};
+	if (!fieldMap) return out;
+	for (const [field, property] of Object.entries(fieldMap)) {
+		const value = formData[field];
+		if (value) out[property] = value;
+	}
+	return out;
+}
+function mapAttribution(event, trackingFields) {
+	const out = {};
+	if (!event.tracking || !trackingFields) return out;
+	for (const [key, property] of Object.entries(trackingFields)) {
+		const value = event.tracking[key];
+		if (value !== void 0 && value !== "") out[property] = String(value);
+	}
+	return out;
+}
+function mapSubmission(event, config) {
+	const formData = event.formData ?? {};
+	const identity = identifySubmitter(formData);
+	return {
+		firstName: identity.firstName,
+		lastName: identity.lastName,
+		email: identity.email,
+		phone: identity.phone ?? event.phone,
+		company: identity.company,
+		message: formData["message"] ?? formData["comments"] ?? formData["comment"],
+		extra: mapExtra(formData, config.fieldMap),
+		attribution: mapAttribution(event, config.trackingFields)
+	};
+}
+
+//#endregion
+//#region src/crm/zoho-token.ts
+const ZOHO_ACCOUNTS_HOSTS = {
+	com: "accounts.zoho.com",
+	ca: "accounts.zohocloud.ca",
+	eu: "accounts.zoho.eu",
+	in: "accounts.zoho.in",
+	"com.au": "accounts.zoho.com.au",
+	jp: "accounts.zoho.jp"
+};
+function zohoAccountsHost(dataCenter) {
+	return ZOHO_ACCOUNTS_HOSTS[dataCenter] ?? ZOHO_ACCOUNTS_HOSTS.com;
+}
+/** Refresh a few seconds before Zoho actually expires it, so a token that's
+* about to lapse mid-request is never handed out. */
+const EXPIRY_MARGIN_MS$1 = 6e4;
+const cache$1 = /* @__PURE__ */ new Map();
+/**
+* Exchange a refresh token for a short-lived Bigin access token, reusing a
+* cached one while it's still valid.
+*
+* `now` is a parameter so cache expiry is testable without a fake clock, the
+* same convention `google/token.ts`'s `googleAccessToken` uses.
+*/
+async function zohoAccessToken(oauth, dataCenter, fetchImpl = fetch, now = Date.now()) {
+	const cached = cache$1.get(oauth.refreshToken);
+	if (cached && cached.expiresAt > now) return cached.accessToken;
+	const body = new URLSearchParams({
+		grant_type: "refresh_token",
+		client_id: oauth.clientId,
+		client_secret: oauth.clientSecret,
+		refresh_token: oauth.refreshToken
+	});
+	const res = await fetchImpl(`https://${zohoAccountsHost(dataCenter)}/oauth/v2/token`, {
+		method: "POST",
+		headers: { "content-type": "application/x-www-form-urlencoded" },
+		body: body.toString()
+	});
+	if (!res.ok) throw new Error(`Zoho token exchange failed (${res.status}): ${await res.text()}`);
+	const json = await res.json();
+	if (!json.access_token) throw new Error(`Zoho token exchange returned no access_token: ${json.error ?? "unknown error"}`);
+	const expiresAt = now + (json.expires_in ?? 3600) * 1e3 - EXPIRY_MARGIN_MS$1;
+	cache$1.set(oauth.refreshToken, {
+		accessToken: json.access_token,
+		expiresAt
+	});
+	return json.access_token;
+}
+/** Test-only: clear the module-level cache between cases. */
+function clearZohoTokenCache() {
+	cache$1.clear();
+}
+
+//#endregion
+//#region src/crm/bigin.ts
+/**
+* Zoho Bigin executor — decides nothing except the one thing it must refuse
+* to send: a record with no derivable last name (see `deriveLastName` in
+* `map.ts`). Everything else is "build the request, post it, classify the
+* response."
+*
+* `upsert` with `duplicate_check_fields: ['Email']` (configurable) rather than
+* plain `Contacts` create — a visitor resubmitting the same form (a second
+* enquiry, a retried failed submission) should update one contact, not create
+* a duplicate every time.
+*/
+const ZOHO_API_HOSTS = {
+	com: "www.zohoapis.com",
+	ca: "www.zohoapis.ca",
+	eu: "www.zohoapis.eu",
+	in: "www.zohoapis.in",
+	"com.au": "www.zohoapis.com.au",
+	jp: "www.zohoapis.jp"
+};
+function zohoApiHost(dataCenter) {
+	return ZOHO_API_HOSTS[dataCenter] ?? ZOHO_API_HOSTS.com;
+}
+function biginFields(record, lastName) {
+	return {
+		Last_Name: lastName,
+		...record.firstName ? { First_Name: record.firstName } : {},
+		...record.email ? { Email: record.email } : {},
+		...record.phone ? { Phone: record.phone } : {},
+		...record.company ? { Account_Name: record.company } : {},
+		...record.message ? { Description: record.message } : {},
+		...record.extra,
+		...record.attribution,
+		Lead_Source: "Website"
+	};
+}
+/**
+* Write one record to Bigin. Never throws — a token-exchange failure, a
+* network error and a rejected response all come back as `CrmResult`.
+*/
+async function submitToBigin(record, config, credentials, fetchImpl = fetch, timeoutMs = 5e3) {
+	const derived = deriveLastName({
+		firstName: record.firstName,
+		lastName: record.lastName,
+		fullName: [record.firstName, record.lastName].filter(Boolean).join(" ") || record.email || "",
+		email: record.email
+	});
+	if ("refusal" in derived) return {
+		ok: false,
+		provider: "bigin",
+		reason: derived.refusal
+	};
+	let token;
+	try {
+		token = await zohoAccessToken(credentials, config.dataCenter, fetchImpl);
+	} catch (err) {
+		return {
+			ok: false,
+			provider: "bigin",
+			reason: `Zoho token exchange failed: ${err instanceof Error ? err.message : String(err)}`
+		};
+	}
+	const host = zohoApiHost(config.dataCenter);
+	const url = `https://${host}/bigin/v2/Contacts/upsert`;
+	const body = {
+		data: [biginFields(record, derived.lastName)],
+		duplicate_check_fields: [config.duplicateCheckField ?? "Email"],
+		trigger: ["workflow"]
+	};
+	let res;
+	try {
+		res = await fetchImpl(url, {
+			method: "POST",
+			headers: {
+				"content-type": "application/json",
+				authorization: `Zoho-oauthtoken ${token}`
+			},
+			body: JSON.stringify(body),
+			signal: AbortSignal.timeout(timeoutMs)
+		});
+	} catch (err) {
+		return {
+			ok: false,
+			provider: "bigin",
+			reason: `Bigin request failed: ${err instanceof Error ? err.message : String(err)}`
+		};
+	}
+	const text = await res.text().catch(() => "");
+	if (!res.ok) return {
+		ok: false,
+		provider: "bigin",
+		code: String(res.status),
+		reason: `Bigin responded ${res.status}: ${text}`
+	};
+	let json;
+	try {
+		json = JSON.parse(text);
+	} catch {
+		return {
+			ok: false,
+			provider: "bigin",
+			reason: `Bigin returned an unparsable response: ${text}`
+		};
+	}
+	const entry = json.data?.[0];
+	if (!entry || entry.status !== "success") return {
+		ok: false,
+		provider: "bigin",
+		code: entry?.code,
+		reason: `Bigin upsert did not succeed: ${text}`
+	};
+	const contactId = entry.details?.id;
+	if (config.pipeline?.enabled && contactId) await createPipelineRecord(record, config, contactId, host, token, fetchImpl, timeoutMs).catch(() => void 0);
+	return {
+		ok: true,
+		provider: "bigin",
+		recordId: contactId
+	};
+}
+async function createPipelineRecord(record, config, contactId, host, token, fetchImpl, timeoutMs) {
+	const pipeline = config.pipeline;
+	const body = {
+		data: [{
+			Pipeline_Name: record.company || record.email || "Website enquiry",
+			Contact_Name: contactId,
+			...pipeline.subPipeline ? { Sub_Pipeline: pipeline.subPipeline } : {},
+			...pipeline.stage ? { Stage: pipeline.stage } : {}
+		}],
+		trigger: ["workflow"]
+	};
+	await fetchImpl(`https://${host}/bigin/v2/Pipelines`, {
+		method: "POST",
+		headers: {
+			"content-type": "application/json",
+			authorization: `Zoho-oauthtoken ${token}`
+		},
+		body: JSON.stringify(body),
+		signal: AbortSignal.timeout(timeoutMs)
+	});
+}
+
+//#endregion
+//#region src/crm/hubspot.ts
+const HUBSPOT_HOSTS = {
+	na: "api.hsforms.com",
+	eu: "api-eu1.hsforms.com"
+};
+function fieldsFor(record) {
+	const fields = [];
+	const push = (name, value) => {
+		if (value) fields.push({
+			objectTypeId: "0-1",
+			name,
+			value
+		});
+	};
+	push("firstname", record.firstName);
+	push("lastname", record.lastName);
+	push("email", record.email);
+	push("phone", record.phone);
+	push("company", record.company);
+	push("message", record.message);
+	for (const [name, value] of Object.entries(record.extra)) push(name, value);
+	for (const [name, value] of Object.entries(record.attribution)) push(name, value);
+	return fields;
+}
+/**
+* Submit one record to HubSpot's secure forms endpoint.
+*
+* Never throws — a network failure or an unparsable response both come back
+* as a `CrmResult` with `ok: false`, the same "structured result, not an
+* exception" rule `security/turnstile.ts` and `indexing/gsc.ts` follow. Status
+* classification: 401 is a rejected/expired token; 400 naming
+* `MISSING_REQUIRED_FIELDS` or an unrecognised field name is a mapping
+* problem (`fieldMap`/`trackingFields` naming a property that isn't on the
+* form); 429 is the per-portal rate limit.
+*/
+async function submitToHubSpot(record, config, credentials, context = {}, fetchImpl = fetch, timeoutMs = 5e3) {
+	const url = `https://${HUBSPOT_HOSTS[config.dataCenter ?? "na"]}/submissions/v3/integration/secure/submit/${config.portalId}/${config.formGuid}`;
+	const body = {
+		fields: fieldsFor(record),
+		context: {
+			...context.hutk ? { hutk: context.hutk } : {},
+			...context.pageUri ? { pageUri: context.pageUri } : {},
+			...context.pageName ? { pageName: context.pageName } : {}
+		}
+	};
+	let res;
+	try {
+		res = await fetchImpl(url, {
+			method: "POST",
+			headers: {
+				"content-type": "application/json",
+				authorization: `Bearer ${credentials.accessToken}`
+			},
+			body: JSON.stringify(body),
+			signal: AbortSignal.timeout(timeoutMs)
+		});
+	} catch (err) {
+		return {
+			ok: false,
+			provider: "hubspot",
+			reason: `HubSpot request failed: ${err instanceof Error ? err.message : String(err)}`
+		};
+	}
+	if (res.ok) return {
+		ok: true,
+		provider: "hubspot"
+	};
+	const text = await res.text().catch(() => "");
+	if (res.status === 401) return {
+		ok: false,
+		provider: "hubspot",
+		code: "401",
+		reason: `HubSpot rejected the access token: ${text}`
+	};
+	if (res.status === 429) return {
+		ok: false,
+		provider: "hubspot",
+		code: "429",
+		reason: "HubSpot rate limit exceeded for this portal."
+	};
+	if (res.status === 400 && /MISSING_REQUIRED_FIELDS|not.*(a|an).*(valid|known).*field/i.test(text)) return {
+		ok: false,
+		provider: "hubspot",
+		code: "400",
+		reason: `HubSpot rejected the mapped fields — check \`fieldMap\`/\`trackingFields\` against the form's own fields: ${text}`
+	};
+	return {
+		ok: false,
+		provider: "hubspot",
+		code: String(res.status),
+		reason: `HubSpot responded ${res.status}: ${text}`
+	};
+}
+
+//#endregion
+//#region src/crm/jobber-token.ts
+/**
+* Jobber OAuth2 refresh-token exchange.
+*
+* A plain `application/x-www-form-urlencoded` POST, same shape as Zoho's —
+* see `zoho-token.ts` for why that keeps this Worker-safe (no `node:crypto`,
+* unlike `google/token.ts`'s service-account JWT).
+*
+* One thing Zoho's grant never does: Jobber's Refresh Token Rotation is ON by
+* default for a new app, and when it's on, every exchange returns a *new*
+* refresh token and invalidates the old one. A Worker reading a static env
+* var (`VITOPS_JOBBER_REFRESH_TOKEN`) cannot persist that new value, so this
+* integration requires rotation turned OFF in the app's Developer Center
+* settings — a legitimate setup requirement, since a per-client private app
+* is never published to Jobber's Marketplace (where rotation ON is
+* mandatory). `zohoAccessToken`'s Zoho equivalent has no such failure mode to
+* detect, because Zoho's grant is long-lived by default.
+*
+* Cached per isolate, keyed on the refresh token, with an expiry margin —
+* same rationale as `zoho-token.ts`.
+*/
+const JOBBER_OAUTH_TOKEN_URL = "https://api.getjobber.com/api/oauth/token";
+/** Refresh a few seconds before Jobber actually expires it (access tokens
+* last 60 minutes), so a token that's about to lapse mid-request is never
+* handed out. */
+const EXPIRY_MARGIN_MS = 6e4;
+const cache = /* @__PURE__ */ new Map();
+/**
+* Exchange a refresh token for a short-lived Jobber access token, reusing a
+* cached one while it's still valid.
+*
+* Throws a specific, actionable error when Jobber's response carries a
+* *different* refresh token than the one sent — the rotation case above.
+* Without this check, rotation surfaces an hour later as an opaque 401 on a
+* lead that is already lost; with it, the first submission after rotation
+* turns on names the fix.
+*
+* `now` is a parameter so cache expiry is testable without a fake clock, the
+* same convention `zoho-token.ts`'s `zohoAccessToken` uses.
+*/
+async function jobberAccessToken(oauth, fetchImpl = fetch, now = Date.now()) {
+	const cached = cache.get(oauth.refreshToken);
+	if (cached && cached.expiresAt > now) return cached.accessToken;
+	const body = new URLSearchParams({
+		grant_type: "refresh_token",
+		client_id: oauth.clientId,
+		client_secret: oauth.clientSecret,
+		refresh_token: oauth.refreshToken
+	});
+	const res = await fetchImpl(JOBBER_OAUTH_TOKEN_URL, {
+		method: "POST",
+		headers: { "content-type": "application/x-www-form-urlencoded" },
+		body: body.toString()
+	});
+	if (!res.ok) throw new Error(`Jobber token exchange failed (${res.status}): ${await res.text()}`);
+	const json = await res.json();
+	if (!json.access_token) throw new Error(`Jobber token exchange returned no access_token: ${json.error ?? "unknown error"}`);
+	if (json.refresh_token && json.refresh_token !== oauth.refreshToken) throw new Error("Jobber returned a rotated refresh token. Turn Refresh Token Rotation off for this app in Jobber's Developer Center — a rotated token cannot be persisted from a stateless Worker reading a static VITOPS_JOBBER_REFRESH_TOKEN.");
+	const expiresAt = now + (json.expires_in ?? 3600) * 1e3 - EXPIRY_MARGIN_MS;
+	cache.set(oauth.refreshToken, {
+		accessToken: json.access_token,
+		expiresAt
+	});
+	return json.access_token;
+}
+/** Test-only: clear the module-level cache between cases. */
+function clearJobberTokenCache() {
+	cache.clear();
+}
+
+//#endregion
+//#region src/crm/jobber.ts
+const JOBBER_GRAPHQL_ENDPOINT = "https://api.getjobber.com/api/graphql";
+/** Pinned to the version this integration was built and tested against.
+* Jobber's `X-JOBBER-GRAPHQL-VERSION` header is mandatory — an unversioned
+* request is rejected outright — so this is code, not something left to
+* config to supply by default. `config.jobber.apiVersion` is the escape
+* hatch for a client's app pinned to a different one. */
+const JOBBER_API_VERSION = "2025-04-16";
+function clientCreateInput(record) {
+	return {
+		...record.firstName ? { firstName: record.firstName } : {},
+		...record.lastName ? { lastName: record.lastName } : {},
+		...record.company ? { companyName: record.company } : {},
+		...record.email ? { emails: [{
+			description: "MAIN",
+			primary: true,
+			address: record.email
+		}] } : {},
+		...record.phone ? { phones: [{
+			description: "MAIN",
+			primary: true,
+			number: record.phone
+		}] } : {}
+	};
+}
+/** Note body: the submitted message plus every attribution/extra field that
+* has no dedicated Jobber field, so nothing is lost to the note-vs-field
+* split above. Empty sections are omitted rather than rendered blank. */
+function noteBody(record, pageUri) {
+	const lines = [];
+	if (record.message) lines.push(record.message);
+	const extraEntries = Object.entries(record.extra);
+	if (extraEntries.length) lines.push("", ...extraEntries.map(([k, v]) => `${k}: ${v}`));
+	const attributionEntries = Object.entries(record.attribution);
+	if (attributionEntries.length) lines.push("", "Attribution:", ...attributionEntries.map(([k, v]) => `${k}: ${v}`));
+	if (pageUri) lines.push("", `Submitted from ${pageUri}`);
+	return lines.join("\n").trim();
+}
+async function graphql(query, variables, token, apiVersion, fetchImpl, timeoutMs) {
+	return fetchImpl(JOBBER_GRAPHQL_ENDPOINT, {
+		method: "POST",
+		headers: {
+			"content-type": "application/json",
+			authorization: `Bearer ${token}`,
+			"x-jobber-graphql-version": apiVersion
+		},
+		body: JSON.stringify({
+			query,
+			variables
+		}),
+		signal: AbortSignal.timeout(timeoutMs)
+	});
+}
+const CLIENT_CREATE_MUTATION = `
+  mutation CrmClientCreate($input: ClientCreateInput!) {
+    clientCreate(input: $input) {
+      client { id }
+      userErrors { message }
+    }
+  }
+`;
+/** Best-effort — see the module docblock's note on the unverified
+* `noteCreate` shape. Any failure (transport, GraphQL error, or the mutation
+* simply not existing under this name) is swallowed by the caller. */
+const NOTE_CREATE_MUTATION = `
+  mutation CrmNoteCreate($input: NoteCreateInput!) {
+    noteCreate(input: $input) {
+      note { id }
+      userErrors { message }
+    }
+  }
+`;
+async function createNote(clientId, message, token, apiVersion, fetchImpl, timeoutMs) {
+	if (!message) return;
+	const json = await (await graphql(NOTE_CREATE_MUTATION, { input: {
+		clientId,
+		message
+	} }, token, apiVersion, fetchImpl, timeoutMs)).json();
+	if (json.errors?.length) throw new Error(json.errors.map((e) => e.message).join("; "));
+	const userErrors = json.data?.noteCreate?.userErrors;
+	if (userErrors?.length) throw new Error(userErrors.map((e) => e.message).join("; "));
+}
+/** Best-effort — see the module docblock's note on the unverified `clients`
+* filter shape. A failure (or the field simply not matching this account's
+* schema) means "could not dedupe", not "stop the submission" — falls
+* through to creating a new client. */
+const FIND_CLIENT_BY_EMAIL_QUERY = `
+  query CrmFindClientByEmail($searchTerm: String!) {
+    clients(first: 1, searchTerm: $searchTerm) {
+      nodes { id }
+    }
+  }
+`;
+async function findExistingClientId(email, token, apiVersion, fetchImpl, timeoutMs) {
+	const json = await (await graphql(FIND_CLIENT_BY_EMAIL_QUERY, { searchTerm: email }, token, apiVersion, fetchImpl, timeoutMs)).json();
+	if (json.errors?.length) throw new Error(json.errors.map((e) => e.message).join("; "));
+	return json.data?.clients?.nodes?.[0]?.id;
+}
+/**
+* Write one record to Jobber. Never throws — a token-exchange failure, a
+* network error, a top-level GraphQL `errors[]`, and a `userErrors[]` all
+* come back as a `CrmResult` with `ok: false`.
+*/
+async function submitToJobber(record, config, credentials, pageUri, fetchImpl = fetch, timeoutMs = 5e3) {
+	const apiVersion = config.apiVersion ?? JOBBER_API_VERSION;
+	let token;
+	try {
+		token = await jobberAccessToken(credentials, fetchImpl);
+	} catch (err) {
+		return {
+			ok: false,
+			provider: "jobber",
+			reason: `Jobber token exchange failed: ${err instanceof Error ? err.message : String(err)}`
+		};
+	}
+	if (config.dedupe === true && record.email) try {
+		const existingId = await findExistingClientId(record.email, token, apiVersion, fetchImpl, timeoutMs);
+		if (existingId) {
+			if (config.note?.enabled !== false) await createNote(existingId, noteBody(record, pageUri), token, apiVersion, fetchImpl, timeoutMs).catch(() => void 0);
+			return {
+				ok: true,
+				provider: "jobber",
+				recordId: existingId
+			};
+		}
+	} catch {}
+	let res;
+	try {
+		res = await graphql(CLIENT_CREATE_MUTATION, { input: clientCreateInput(record) }, token, apiVersion, fetchImpl, timeoutMs);
+	} catch (err) {
+		return {
+			ok: false,
+			provider: "jobber",
+			reason: `Jobber request failed: ${err instanceof Error ? err.message : String(err)}`
+		};
+	}
+	if (res.status === 401) return {
+		ok: false,
+		provider: "jobber",
+		code: "401",
+		reason: `Jobber rejected the access token: ${await res.text().catch(() => "")}`
+	};
+	if (res.status === 429) return {
+		ok: false,
+		provider: "jobber",
+		code: "429",
+		reason: "Jobber rate limit exceeded (2,500 requests per 5 minutes)."
+	};
+	if (!res.ok) return {
+		ok: false,
+		provider: "jobber",
+		code: String(res.status),
+		reason: `Jobber responded ${res.status}: ${await res.text().catch(() => "")}`
+	};
+	let json;
+	try {
+		json = await res.json();
+	} catch {
+		return {
+			ok: false,
+			provider: "jobber",
+			reason: "Jobber returned an unparsable response."
+		};
+	}
+	if (json.errors?.length) return {
+		ok: false,
+		provider: "jobber",
+		reason: `Jobber rejected the request: ${json.errors.map((e) => e.message).join("; ")}`
+	};
+	const userErrors = json.data?.clientCreate?.userErrors;
+	if (userErrors?.length) return {
+		ok: false,
+		provider: "jobber",
+		reason: `Jobber rejected the mapped fields: ${userErrors.map((e) => e.message).join("; ")}`
+	};
+	const clientId = json.data?.clientCreate?.client?.id;
+	if (!clientId) return {
+		ok: false,
+		provider: "jobber",
+		reason: "Jobber did not return a client id."
+	};
+	if (config.note?.enabled !== false) await createNote(clientId, noteBody(record, pageUri), token, apiVersion, fetchImpl, timeoutMs).catch(() => void 0);
+	return {
+		ok: true,
+		provider: "jobber",
+		recordId: clientId
+	};
+}
+
+//#endregion
+//#region src/crm/plan.ts
+/**
+* What each provider requires to be considered configured, as one table
+* rather than a per-provider `if`. A provider missing here is a type error —
+* `Record<CrmProvider, …>` — rather than a silently-enabled channel with no
+* config block, which is what the equivalent hand-written checks would do for
+* a provider nobody added a branch for.
+*/
+const PROVIDER_REQUIREMENTS = {
+	hubspot: {
+		block: "hubspot",
+		credentialHint: "No HubSpot access token configured."
+	},
+	bigin: {
+		block: "bigin",
+		credentialHint: "No Zoho OAuth credentials configured."
+	},
+	jobber: {
+		block: "jobber",
+		credentialHint: "No Jobber OAuth credentials configured."
+	}
+};
+function planCrm(config, credentials) {
+	if (!config) return {
+		enabled: false,
+		skip: "No `crm` configured."
+	};
+	if (config.enabled === false) return {
+		enabled: false,
+		provider: config.provider,
+		skip: "`crm.enabled` is false."
+	};
+	const requirement = PROVIDER_REQUIREMENTS[config.provider];
+	if (!config[requirement.block]) return {
+		enabled: false,
+		provider: config.provider,
+		skip: `\`crm.provider\` is "${config.provider}" but \`crm.${requirement.block}\` is missing.`
+	};
+	if (!credentials) return {
+		enabled: false,
+		provider: config.provider,
+		skip: requirement.credentialHint
+	};
+	if (credentials.provider !== config.provider) return {
+		enabled: false,
+		provider: config.provider,
+		skip: `\`crm.provider\` is "${config.provider}" but the supplied credentials are for "${credentials.provider}".`
+	};
+	return {
+		enabled: true,
+		provider: config.provider
+	};
+}
+
+//#endregion
+//#region src/crm/types.ts
+/** Human-readable label per provider, for the notification email's Delivery
+* line (`describeCrmResult`) and anywhere else a provider must be named
+* without a hand-written ternary. Exhaustive by type — a provider missing
+* here is a compile error, not a mislabelled email. */
+const PROVIDER_LABELS = {
+	hubspot: "HubSpot",
+	bigin: "Bigin",
+	jobber: "Jobber"
+};
+
+//#endregion
+//#region src/crm/index.ts
+async function deliverToCrm(event, config, deps = {}) {
+	const plan = planCrm(config, deps.credentials);
+	if (!plan.enabled || !config || !deps.credentials) return config ? {
+		ok: false,
+		provider: config.provider,
+		reason: plan.skip
+	} : null;
+	const record = mapSubmission(event, config);
+	const fetchImpl = deps.fetch ?? fetch;
+	const timeoutMs = deps.timeoutMs ?? 5e3;
+	const credentials = deps.credentials;
+	switch (config.provider) {
+		case "hubspot":
+			if (credentials.provider !== "hubspot") break;
+			return submitToHubSpot(record, config.hubspot, credentials.hubspot, deps.pageContext, fetchImpl, timeoutMs);
+		case "bigin":
+			if (credentials.provider !== "bigin") break;
+			return submitToBigin(record, config.bigin, credentials.bigin, fetchImpl, timeoutMs);
+		case "jobber":
+			if (credentials.provider !== "jobber") break;
+			return submitToJobber(record, config.jobber ?? {}, credentials.jobber, deps.pageContext?.pageUri, fetchImpl, timeoutMs);
+		default: return config.provider;
+	}
+	return {
+		ok: false,
+		provider: config.provider,
+		reason: plan.skip ?? "Credentials/provider mismatch."
+	};
+}
+/** A one-line, human-readable delivery note — what `conversion.ts` folds into
+* the notification email's "Delivery" section. */
+function describeCrmResult(result) {
+	if (!result) return null;
+	const name = PROVIDER_LABELS[result.provider];
+	if (result.ok) return result.recordId ? `Written to ${name} (contact ${result.recordId})` : `Written to ${name}`;
+	return `⚠ Not written to ${name}: ${result.reason ?? "unknown reason"}`;
+}
+
+//#endregion
+export { PROVIDER_LABELS, clearJobberTokenCache, clearZohoTokenCache, deliverToCrm, deriveLastName, describeCrmResult, jobberAccessToken, mapSubmission, planCrm, submitToBigin, submitToHubSpot, submitToJobber, zohoAccessToken, zohoAccountsHost, zohoApiHost };
+//# sourceMappingURL=index.mjs.map