@10x-media/form-builder 0.1.0-beta.2 → 0.1.0-beta.21

package/dist/poll/resolvePollOutcome.js

@@ -0,0 +1,90 @@
+import { pollConfigOf } from "../form/pollState.js";
+import { aggregateFieldResponses } from "../aggregation/aggregateResponses.js";
+import { resolveEffectivePollOptions } from "./effectivePollOptions.js";
+import { pollTypesOf } from "./pollTypeRegistry.js";
+import { aggregateFromVotes } from "./votes/aggregateFromVotes.js";
+import { FORMS_SLUG } from "../collections/forms.js";
+//#region src/poll/resolvePollOutcome.ts
+/** A strategy result narrowed to a deduped set of non-empty strings. */
+const cleanWinners = (value) => value === void 0 ? [] : [...new Set(value.filter((entry) => typeof entry === "string" && entry.length > 0))];
+/**
+* Record a poll's final outcome server-side, in one of two modes:
+* - explicit: pass `winningValues` when host code already knows the winner(s); more than one is a
+*   tie, and an empty array clears the outcome;
+* - auto: omit it and the poll's selected outcome strategy (`poll.type`, from the `poll.types`
+*   registry, defaulting to `manual`) resolves the winners. `manual` is a no-op; `mostVoted` reads
+*   the aggregated results field; `source` delegates to the option source. A strategy that is not
+*   yet decidable (or `manual`) writes nothing and this returns an empty set, so auto mode is safe
+*   to call repeatedly from the close job and the read fallback.
+*
+* Every write runs through `payload.update` with `overrideAccess`, so the forms collection hook
+* validates each value against the poll's effective options and owns the `poll.outcome.resolvedAt`
+* stamp in both modes (auto-resolved winners are validated exactly as hand-picked ones). Throws only
+* when the form does not exist or is not poll-enabled. Returns the recorded winning set (empty when
+* auto mode did not decide).
+*/
+const resolvePollOutcome = async (args) => {
+	const { payload, formId, pollVotesEnabled, req } = args;
+	const form = await payload.findByID({
+		collection: FORMS_SLUG,
+		id: formId,
+		depth: 0,
+		overrideAccess: true,
+		req
+	});
+	const poll = pollConfigOf(form.poll);
+	if (form.pollEnabled !== true || !poll) throw new Error(`Form ${String(formId)} is not poll-enabled; cannot record an outcome.`);
+	let winningValues;
+	if (args.winningValues !== void 0) winningValues = args.winningValues;
+	else {
+		const strategyType = typeof poll.type === "string" && poll.type.length > 0 ? poll.type : "manual";
+		const strategy = pollTypesOf(payload).get(strategyType);
+		if (!strategy) return [];
+		let aggregated;
+		const aggregate = async () => {
+			if (aggregated === void 0) {
+				const resultsField = typeof poll.resultsField === "string" && poll.resultsField.length > 0 ? poll.resultsField : void 0;
+				if (!resultsField) aggregated = null;
+				else if (pollVotesEnabled === true) aggregated = await aggregateFromVotes({
+					payload,
+					formId,
+					field: resultsField,
+					options: await resolveEffectivePollOptions({
+						payload,
+						req,
+						form
+					}).catch(() => []),
+					req
+				});
+				else aggregated = await aggregateFieldResponses({
+					payload,
+					formId,
+					field: resultsField,
+					req
+				});
+			}
+			return aggregated;
+		};
+		winningValues = cleanWinners(await strategy.resolveOutcome({
+			payload,
+			req,
+			form,
+			poll,
+			aggregate
+		}));
+		if (winningValues.length === 0) return [];
+	}
+	await payload.update({
+		collection: FORMS_SLUG,
+		id: formId,
+		data: { poll: { outcome: { winningValues } } },
+		depth: 0,
+		overrideAccess: true,
+		req
+	});
+	return winningValues;
+};
+//#endregion
+export { resolvePollOutcome };
+
+//# sourceMappingURL=resolvePollOutcome.js.map

package/dist/poll/resolvePollOutcome.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolvePollOutcome.js","names":[],"sources":["../../src/poll/resolvePollOutcome.ts"],"sourcesContent":["import type { Payload, PayloadRequest } from 'payload'\nimport { aggregateFieldResponses } from '../aggregation/aggregateResponses'\nimport type { FieldAggregation } from '../aggregation/types'\nimport { FORMS_SLUG } from '../collections/forms'\nimport { pollConfigOf } from '../form/pollState'\nimport type { PollOutcomeStrategyArgs } from './definePollType'\nimport { resolveEffectivePollOptions } from './effectivePollOptions'\nimport { pollTypesOf } from './pollTypeRegistry'\nimport { aggregateFromVotes } from './votes/aggregateFromVotes'\n\nexport type ResolvePollOutcomeArgs = {\n\tpayload: Payload\n\tformId: number | string\n\t/**\n\t * The winning set: stable option values, each matching one of the poll's choice values (the\n\t * host's contract with `PollOption.value`). Pass more than one for a tie, an empty array to clear\n\t * the outcome. Omit to auto-resolve via the poll's selected outcome strategy (`poll.type`).\n\t */\n\twinningValues?: string[]\n\t/**\n\t * Whether the hidden tally store backs the auto-resolve aggregation (`mostVoted` and any host\n\t * strategy that calls `aggregate()`). False keeps the submission scan, so persist-off forms\n\t * only resolve correctly with the store enabled.\n\t */\n\tpollVotesEnabled?: boolean\n\treq?: PayloadRequest\n}\n\n/** A strategy result narrowed to a deduped set of non-empty strings. */\nconst cleanWinners = (value: string[] | undefined): string[] =>\n\tvalue === undefined\n\t\t? []\n\t\t: [\n\t\t\t\t...new Set(\n\t\t\t\t\tvalue.filter((entry): entry is string => typeof entry === 'string' && entry.length > 0)\n\t\t\t\t),\n\t\t\t]\n\n/**\n * Record a poll's final outcome server-side, in one of two modes:\n * - explicit: pass `winningValues` when host code already knows the winner(s); more than one is a\n *   tie, and an empty array clears the outcome;\n * - auto: omit it and the poll's selected outcome strategy (`poll.type`, from the `poll.types`\n *   registry, defaulting to `manual`) resolves the winners. `manual` is a no-op; `mostVoted` reads\n *   the aggregated results field; `source` delegates to the option source. A strategy that is not\n *   yet decidable (or `manual`) writes nothing and this returns an empty set, so auto mode is safe\n *   to call repeatedly from the close job and the read fallback.\n *\n * Every write runs through `payload.update` with `overrideAccess`, so the forms collection hook\n * validates each value against the poll's effective options and owns the `poll.outcome.resolvedAt`\n * stamp in both modes (auto-resolved winners are validated exactly as hand-picked ones). Throws only\n * when the form does not exist or is not poll-enabled. Returns the recorded winning set (empty when\n * auto mode did not decide).\n */\nexport const resolvePollOutcome = async (args: ResolvePollOutcomeArgs): Promise<string[]> => {\n\tconst { payload, formId, pollVotesEnabled, req } = args\n\tconst form = await payload.findByID({\n\t\tcollection: FORMS_SLUG,\n\t\tid: formId,\n\t\tdepth: 0,\n\t\toverrideAccess: true,\n\t\treq,\n\t})\n\tconst poll = pollConfigOf(form.poll)\n\tif (form.pollEnabled !== true || !poll) {\n\t\tthrow new Error(`Form ${String(formId)} is not poll-enabled; cannot record an outcome.`)\n\t}\n\n\tlet winningValues: string[]\n\tif (args.winningValues !== undefined) {\n\t\twinningValues = args.winningValues\n\t} else {\n\t\tconst strategyType =\n\t\t\ttypeof poll.type === 'string' && poll.type.length > 0 ? poll.type : 'manual'\n\t\tconst strategy = pollTypesOf(payload).get(strategyType)\n\t\tif (!strategy) {\n\t\t\treturn []\n\t\t}\n\t\tlet aggregated: FieldAggregation | null | undefined\n\t\tconst aggregate = async (): Promise<FieldAggregation | null> => {\n\t\t\tif (aggregated === undefined) {\n\t\t\t\tconst resultsField =\n\t\t\t\t\ttypeof poll.resultsField === 'string' && poll.resultsField.length > 0\n\t\t\t\t\t\t? poll.resultsField\n\t\t\t\t\t\t: undefined\n\t\t\t\tif (!resultsField) {\n\t\t\t\t\taggregated = null\n\t\t\t\t} else if (pollVotesEnabled === true) {\n\t\t\t\t\t// Best-effort options: a source/resolver failure degrades to raw tally values\n\t\t\t\t\t// (the outcome hook still validates winners against the effective options).\n\t\t\t\t\tconst options = await resolveEffectivePollOptions({ payload, req, form }).catch(() => [])\n\t\t\t\t\taggregated = await aggregateFromVotes({\n\t\t\t\t\t\tpayload,\n\t\t\t\t\t\tformId,\n\t\t\t\t\t\tfield: resultsField,\n\t\t\t\t\t\toptions,\n\t\t\t\t\t\treq,\n\t\t\t\t\t})\n\t\t\t\t} else {\n\t\t\t\t\taggregated = await aggregateFieldResponses({ payload, formId, field: resultsField, req })\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn aggregated\n\t\t}\n\t\twinningValues = cleanWinners(\n\t\t\tawait strategy.resolveOutcome({\n\t\t\t\tpayload,\n\t\t\t\treq,\n\t\t\t\tform: form as unknown as PollOutcomeStrategyArgs['form'],\n\t\t\t\tpoll,\n\t\t\t\taggregate,\n\t\t\t})\n\t\t)\n\t\tif (winningValues.length === 0) {\n\t\t\treturn []\n\t\t}\n\t}\n\n\tawait payload.update({\n\t\tcollection: FORMS_SLUG,\n\t\tid: formId,\n\t\tdata: { poll: { outcome: { winningValues } } },\n\t\tdepth: 0,\n\t\toverrideAccess: true,\n\t\treq,\n\t})\n\treturn winningValues\n}\n"],"mappings":";;;;;;;;AA6BA,MAAM,gBAAgB,UACrB,UAAU,KAAA,IACP,CAAC,IACD,CACA,GAAG,IAAI,IACN,MAAM,QAAQ,UAA2B,OAAO,UAAU,YAAY,MAAM,SAAS,CAAC,CACvF,CACD;;;;;;;;;;;;;;;;;AAkBH,MAAa,qBAAqB,OAAO,SAAoD;CAC5F,MAAM,EAAE,SAAS,QAAQ,kBAAkB,QAAQ;CACnD,MAAM,OAAO,MAAM,QAAQ,SAAS;EACnC,YAAY;EACZ,IAAI;EACJ,OAAO;EACP,gBAAgB;EAChB;CACD,CAAC;CACD,MAAM,OAAO,aAAa,KAAK,IAAI;CACnC,IAAI,KAAK,gBAAgB,QAAQ,CAAC,MACjC,MAAM,IAAI,MAAM,QAAQ,OAAO,MAAM,EAAE,gDAAgD;CAGxF,IAAI;CACJ,IAAI,KAAK,kBAAkB,KAAA,GAC1B,gBAAgB,KAAK;MACf;EACN,MAAM,eACL,OAAO,KAAK,SAAS,YAAY,KAAK,KAAK,SAAS,IAAI,KAAK,OAAO;EACrE,MAAM,WAAW,YAAY,OAAO,EAAE,IAAI,YAAY;EACtD,IAAI,CAAC,UACJ,OAAO,CAAC;EAET,IAAI;EACJ,MAAM,YAAY,YAA8C;GAC/D,IAAI,eAAe,KAAA,GAAW;IAC7B,MAAM,eACL,OAAO,KAAK,iBAAiB,YAAY,KAAK,aAAa,SAAS,IACjE,KAAK,eACL,KAAA;IACJ,IAAI,CAAC,cACJ,aAAa;SACP,IAAI,qBAAqB,MAI/B,aAAa,MAAM,mBAAmB;KACrC;KACA;KACA,OAAO;KACP,SAAA,MALqB,4BAA4B;MAAE;MAAS;MAAK;KAAK,CAAC,EAAE,YAAY,CAAC,CAAC;KAMvF;IACD,CAAC;SAED,aAAa,MAAM,wBAAwB;KAAE;KAAS;KAAQ,OAAO;KAAc;IAAI,CAAC;GAE1F;GACA,OAAO;EACR;EACA,gBAAgB,aACf,MAAM,SAAS,eAAe;GAC7B;GACA;GACM;GACN;GACA;EACD,CAAC,CACF;EACA,IAAI,cAAc,WAAW,GAC5B,OAAO,CAAC;CAEV;CAEA,MAAM,QAAQ,OAAO;EACpB,YAAY;EACZ,IAAI;EACJ,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,cAAc,EAAE,EAAE;EAC7C,OAAO;EACP,gBAAgB;EAChB;CACD,CAAC;CACD,OAAO;AACR"}

package/dist/poll/resultsField.js

@@ -0,0 +1,21 @@
+import { fieldNamesOfType } from "../fields/fieldNamesOfType.js";
+import { keys } from "../translations/keys.js";
+import { asTranslate } from "../translations/server.js";
+//#region src/poll/resultsField.ts
+/** Slugs of registered field types choosable as a poll's results field (`pollEligible: true`). */
+const pollEligibleTypes = (registry) => [...registry.values()].filter((definition) => definition.pollEligible === true).map((definition) => definition.type);
+/**
+* Validate for `poll.resultsField`, closed over the eligible type slugs derived from the registry
+* at collection-build time (mirrors the confirmation action's `toField`): unset is fine, otherwise
+* the value must name an existing, named field instance whose type is poll-eligible. Payload skips
+* the validate while the poll is disabled (the field's `admin.condition`), so a stale reference on
+* a disabled poll never blocks a save.
+*/
+const buildValidateResultsField = (eligibleTypes) => (value, { data, req }) => {
+	if (typeof value !== "string" || value.length === 0) return true;
+	return fieldNamesOfType(data && typeof data === "object" ? data.fields : void 0, eligibleTypes).includes(value) ? true : asTranslate(req.t)(keys.validationResultsFieldUnknown);
+};
+//#endregion
+export { buildValidateResultsField, pollEligibleTypes };
+
+//# sourceMappingURL=resultsField.js.map

package/dist/poll/resultsField.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resultsField.js","names":[],"sources":["../../src/poll/resultsField.ts"],"sourcesContent":["import type { PayloadRequest } from 'payload'\nimport { fieldNamesOfType } from '../fields/fieldNamesOfType'\nimport type { FieldTypeRegistry } from '../fields/registry'\nimport { keys } from '../translations/keys'\nimport { asTranslate } from '../translations/server'\n\n/** Slugs of registered field types choosable as a poll's results field (`pollEligible: true`). */\nexport const pollEligibleTypes = (registry: FieldTypeRegistry): string[] =>\n\t[...registry.values()]\n\t\t.filter((definition) => definition.pollEligible === true)\n\t\t.map((definition) => definition.type)\n\n/**\n * Validate for `poll.resultsField`, closed over the eligible type slugs derived from the registry\n * at collection-build time (mirrors the confirmation action's `toField`): unset is fine, otherwise\n * the value must name an existing, named field instance whose type is poll-eligible. Payload skips\n * the validate while the poll is disabled (the field's `admin.condition`), so a stale reference on\n * a disabled poll never blocks a save.\n */\nexport const buildValidateResultsField =\n\t(eligibleTypes: readonly string[]) =>\n\t(value: unknown, { data, req }: { data?: unknown; req: PayloadRequest }): string | true => {\n\t\tif (typeof value !== 'string' || value.length === 0) {\n\t\t\treturn true\n\t\t}\n\t\tconst fields =\n\t\t\tdata && typeof data === 'object' ? (data as Record<string, unknown>).fields : undefined\n\t\treturn fieldNamesOfType(fields, eligibleTypes).includes(value)\n\t\t\t? true\n\t\t\t: asTranslate(req.t)(keys.validationResultsFieldUnknown)\n\t}\n"],"mappings":";;;;;AAOA,MAAa,qBAAqB,aACjC,CAAC,GAAG,SAAS,OAAO,CAAC,EACnB,QAAQ,eAAe,WAAW,iBAAiB,IAAI,EACvD,KAAK,eAAe,WAAW,IAAI;;;;;;;;AAStC,MAAa,6BACX,mBACA,OAAgB,EAAE,MAAM,UAAkE;CAC1F,IAAI,OAAO,UAAU,YAAY,MAAM,WAAW,GACjD,OAAO;CAIR,OAAO,iBADN,QAAQ,OAAO,SAAS,WAAY,KAAiC,SAAS,KAAA,GAC/C,aAAa,EAAE,SAAS,KAAK,IAC1D,OACA,YAAY,IAAI,CAAC,EAAE,KAAK,6BAA6B;AACzD"}

package/dist/poll/votes/aggregateFromVotes.d.ts

@@ -0,0 +1,27 @@
+import { FieldAggregation } from "../../aggregation/types.js";
+import { Payload, PayloadRequest } from "payload";
+
+//#region src/poll/votes/aggregateFromVotes.d.ts
+/**
+ * Poll results from the tally store: one find over the form's rows for the field (O(options),
+ * no scan, no truncation), buckets zero-seeded from the effective options so order and labels
+ * match the scan-based shape. Counts sum across shard rows (see VOTE_SHARDS). `total` comes
+ * from the respondents rows, keeping the percentage denominator exact for multi-value answers.
+ */
+declare const aggregateFromVotes: (args: {
+  payload: Payload;
+  formId: number | string;
+  field: string;
+  meta?: {
+    label?: string;
+    fieldType?: string;
+  };
+  options: {
+    value: string;
+    label: string;
+  }[];
+  req?: PayloadRequest;
+}) => Promise<FieldAggregation>;
+//#endregion
+export { aggregateFromVotes };
+//# sourceMappingURL=aggregateFromVotes.d.ts.map

package/dist/poll/votes/aggregateFromVotes.js

@@ -0,0 +1,54 @@
+import { POLL_VOTES_SLUG } from "./votesCollection.js";
+//#region src/poll/votes/aggregateFromVotes.ts
+const round1 = (n) => Math.round(n * 10) / 10;
+/**
+* Poll results from the tally store: one find over the form's rows for the field (O(options),
+* no scan, no truncation), buckets zero-seeded from the effective options so order and labels
+* match the scan-based shape. Counts sum across shard rows (see VOTE_SHARDS). `total` comes
+* from the respondents rows, keeping the percentage denominator exact for multi-value answers.
+*/
+const aggregateFromVotes = async (args) => {
+	const { payload, formId, field, meta, options, req } = args;
+	const { docs } = await payload.find({
+		collection: POLL_VOTES_SLUG,
+		where: { and: [{ form: { equals: String(formId) } }, { field: { equals: field } }] },
+		limit: 1e5,
+		pagination: false,
+		depth: 0,
+		overrideAccess: true,
+		req
+	});
+	const counts = /* @__PURE__ */ new Map();
+	let total = 0;
+	for (const doc of docs) {
+		const value = doc.value == null ? "" : String(doc.value);
+		const count = typeof doc.count === "number" ? doc.count : 0;
+		if (value === "") total += count;
+		else counts.set(value, (counts.get(value) ?? 0) + count);
+	}
+	total = Math.max(0, total);
+	const optionValues = new Set(options.map((option) => option.value));
+	const leftovers = [...counts.keys()].filter((value) => !optionValues.has(value)).sort((a, b) => (counts.get(b) ?? 0) - (counts.get(a) ?? 0));
+	const labelByValue = new Map(options.map((option) => [option.value, option.label]));
+	const buckets = [...options.map((option) => option.value), ...leftovers].map((value) => {
+		const count = Math.max(0, counts.get(value) ?? 0);
+		return {
+			value,
+			label: labelByValue.get(value) ?? value,
+			count,
+			percentage: total > 0 ? round1(count / total * 100) : 0
+		};
+	});
+	return {
+		field,
+		label: meta?.label,
+		fieldType: meta?.fieldType,
+		total,
+		buckets,
+		truncated: false
+	};
+};
+//#endregion
+export { aggregateFromVotes };
+
+//# sourceMappingURL=aggregateFromVotes.js.map

package/dist/poll/votes/aggregateFromVotes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregateFromVotes.js","names":[],"sources":["../../../src/poll/votes/aggregateFromVotes.ts"],"sourcesContent":["import type { Payload, PayloadRequest } from 'payload'\nimport type { FieldAggregation } from '../../aggregation/types'\nimport { POLL_VOTES_SLUG, RESPONDENTS_VALUE } from './votesCollection'\n\ntype VoteRow = { field?: unknown; value?: unknown; count?: unknown }\n\nconst round1 = (n: number): number => Math.round(n * 10) / 10\n\n/**\n * Poll results from the tally store: one find over the form's rows for the field (O(options),\n * no scan, no truncation), buckets zero-seeded from the effective options so order and labels\n * match the scan-based shape. Counts sum across shard rows (see VOTE_SHARDS). `total` comes\n * from the respondents rows, keeping the percentage denominator exact for multi-value answers.\n */\nexport const aggregateFromVotes = async (args: {\n\tpayload: Payload\n\tformId: number | string\n\tfield: string\n\tmeta?: { label?: string; fieldType?: string }\n\toptions: { value: string; label: string }[]\n\treq?: PayloadRequest\n}): Promise<FieldAggregation> => {\n\tconst { payload, formId, field, meta, options, req } = args\n\tconst { docs } = await payload.find({\n\t\tcollection: POLL_VOTES_SLUG,\n\t\twhere: { and: [{ form: { equals: String(formId) } }, { field: { equals: field } }] },\n\t\tlimit: 100_000,\n\t\tpagination: false,\n\t\tdepth: 0,\n\t\toverrideAccess: true,\n\t\treq,\n\t})\n\n\tconst counts = new Map<string, number>()\n\tlet total = 0\n\tfor (const doc of docs as VoteRow[]) {\n\t\tconst value = doc.value == null ? RESPONDENTS_VALUE : String(doc.value)\n\t\tconst count = typeof doc.count === 'number' ? doc.count : 0\n\t\tif (value === RESPONDENTS_VALUE) {\n\t\t\ttotal += count\n\t\t} else {\n\t\t\tcounts.set(value, (counts.get(value) ?? 0) + count)\n\t\t}\n\t}\n\n\t// Clamp at read: a concurrent double-change can transiently double-decrement one value (see\n\t// the tally hook's drift note), and a negative bucket count must never surface to a reader.\n\ttotal = Math.max(0, total)\n\n\tconst optionValues = new Set(options.map((option) => option.value))\n\tconst leftovers = [...counts.keys()]\n\t\t.filter((value) => !optionValues.has(value))\n\t\t.sort((a, b) => (counts.get(b) ?? 0) - (counts.get(a) ?? 0))\n\tconst labelByValue = new Map(options.map((option) => [option.value, option.label]))\n\n\tconst buckets = [...options.map((option) => option.value), ...leftovers].map((value) => {\n\t\tconst count = Math.max(0, counts.get(value) ?? 0)\n\t\treturn {\n\t\t\tvalue,\n\t\t\tlabel: labelByValue.get(value) ?? value,\n\t\t\tcount,\n\t\t\tpercentage: total > 0 ? round1((count / total) * 100) : 0,\n\t\t}\n\t})\n\n\treturn {\n\t\tfield,\n\t\tlabel: meta?.label,\n\t\tfieldType: meta?.fieldType,\n\t\ttotal,\n\t\tbuckets,\n\t\ttruncated: false,\n\t}\n}\n"],"mappings":";;AAMA,MAAM,UAAU,MAAsB,KAAK,MAAM,IAAI,EAAE,IAAI;;;;;;;AAQ3D,MAAa,qBAAqB,OAAO,SAOR;CAChC,MAAM,EAAE,SAAS,QAAQ,OAAO,MAAM,SAAS,QAAQ;CACvD,MAAM,EAAE,SAAS,MAAM,QAAQ,KAAK;EACnC,YAAY;EACZ,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,QAAQ,OAAO,MAAM,EAAE,EAAE,GAAG,EAAE,OAAO,EAAE,QAAQ,MAAM,EAAE,CAAC,EAAE;EACnF,OAAO;EACP,YAAY;EACZ,OAAO;EACP,gBAAgB;EAChB;CACD,CAAC;CAED,MAAM,yBAAS,IAAI,IAAoB;CACvC,IAAI,QAAQ;CACZ,KAAK,MAAM,OAAO,MAAmB;EACpC,MAAM,QAAQ,IAAI,SAAS,OAAA,KAA2B,OAAO,IAAI,KAAK;EACtE,MAAM,QAAQ,OAAO,IAAI,UAAU,WAAW,IAAI,QAAQ;EAC1D,IAAI,UAAA,IACH,SAAS;OAET,OAAO,IAAI,QAAQ,OAAO,IAAI,KAAK,KAAK,KAAK,KAAK;CAEpD;CAIA,QAAQ,KAAK,IAAI,GAAG,KAAK;CAEzB,MAAM,eAAe,IAAI,IAAI,QAAQ,KAAK,WAAW,OAAO,KAAK,CAAC;CAClE,MAAM,YAAY,CAAC,GAAG,OAAO,KAAK,CAAC,EACjC,QAAQ,UAAU,CAAC,aAAa,IAAI,KAAK,CAAC,EAC1C,MAAM,GAAG,OAAO,OAAO,IAAI,CAAC,KAAK,MAAM,OAAO,IAAI,CAAC,KAAK,EAAE;CAC5D,MAAM,eAAe,IAAI,IAAI,QAAQ,KAAK,WAAW,CAAC,OAAO,OAAO,OAAO,KAAK,CAAC,CAAC;CAElF,MAAM,UAAU,CAAC,GAAG,QAAQ,KAAK,WAAW,OAAO,KAAK,GAAG,GAAG,SAAS,EAAE,KAAK,UAAU;EACvF,MAAM,QAAQ,KAAK,IAAI,GAAG,OAAO,IAAI,KAAK,KAAK,CAAC;EAChD,OAAO;GACN;GACA,OAAO,aAAa,IAAI,KAAK,KAAK;GAClC;GACA,YAAY,QAAQ,IAAI,OAAQ,QAAQ,QAAS,GAAG,IAAI;EACzD;CACD,CAAC;CAED,OAAO;EACN;EACA,OAAO,MAAM;EACb,WAAW,MAAM;EACjB;EACA;EACA,WAAW;CACZ;AACD"}

package/dist/poll/votes/answerValues.js

@@ -0,0 +1,16 @@
+//#region src/poll/votes/answerValues.ts
+/**
+* A submission's answer(s) for one field as normalized non-empty strings: the shape both the vote
+* tally and the voted-pick resolver count by (a multi-select answer contributes one entry per
+* selected value).
+*/
+const answerValues = (values, field) => {
+	if (!Array.isArray(values)) return [];
+	const entry = values.find((row) => row.field === field);
+	if (entry == null) return [];
+	return (Array.isArray(entry.value) ? entry.value : [entry.value]).filter((value) => value != null && value !== "").map((value) => String(value));
+};
+//#endregion
+export { answerValues };
+
+//# sourceMappingURL=answerValues.js.map

package/dist/poll/votes/answerValues.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"answerValues.js","names":[],"sources":["../../../src/poll/votes/answerValues.ts"],"sourcesContent":["import type { SubmissionValue } from '../../submissions/types'\n\n/**\n * A submission's answer(s) for one field as normalized non-empty strings: the shape both the vote\n * tally and the voted-pick resolver count by (a multi-select answer contributes one entry per\n * selected value).\n */\nexport const answerValues = (values: unknown, field: string): string[] => {\n\tif (!Array.isArray(values)) return []\n\tconst entry = (values as SubmissionValue[]).find((row) => row.field === field)\n\tif (entry == null) return []\n\tconst raw = Array.isArray(entry.value) ? entry.value : [entry.value]\n\treturn raw.filter((value) => value != null && value !== '').map((value) => String(value))\n}\n"],"mappings":";;;;;;AAOA,MAAa,gBAAgB,QAAiB,UAA4B;CACzE,IAAI,CAAC,MAAM,QAAQ,MAAM,GAAG,OAAO,CAAC;CACpC,MAAM,QAAS,OAA6B,MAAM,QAAQ,IAAI,UAAU,KAAK;CAC7E,IAAI,SAAS,MAAM,OAAO,CAAC;CAE3B,QADY,MAAM,QAAQ,MAAM,KAAK,IAAI,MAAM,QAAQ,CAAC,MAAM,KAAK,GACxD,QAAQ,UAAU,SAAS,QAAQ,UAAU,EAAE,EAAE,KAAK,UAAU,OAAO,KAAK,CAAC;AACzF"}

package/dist/poll/votes/bumpPollVote.js

@@ -0,0 +1,88 @@
+import { POLL_VOTES_SLUG } from "./votesCollection.js";
+//#region src/poll/votes/bumpPollVote.ts
+const PG_TABLE_KEY = "form_poll_votes";
+/**
+* Loads the optional Postgres peer without a literal specifier: bundlers (Turbopack, webpack,
+* Vite) resolve literal dynamic imports at build time, which fails a Mongo host's build even
+* though this branch is unreachable there. The function-built specifier is opaque to their
+* analyzers, the ignore comments cover bundlers that would still warn, and the type-only
+* reference above erases at compile time, so the package is touched only when the Postgres
+* branch actually runs.
+*/
+const importPostgresSql = () => {
+	return import(
+		/* webpackIgnore: true */
+		/* turbopackIgnore: true */
+		/* @vite-ignore */
+		["@payloadcms", "db-postgres"].join("/")
+);
+};
+/**
+* Atomically bumps one (form, field, value) tally by `by` in a single upsert-increment
+* statement (Mongo `$inc` + upsert, Postgres `INSERT ... ON CONFLICT DO UPDATE`); the unique
+* compound index makes concurrent bumps for the same key safe without read-modify-write races.
+* The shard column is internal: transactional Mongo bumps pick a random shard in
+* [0, VOTE_SHARDS) so concurrent transactions rarely write the same document (see VOTE_SHARDS);
+* Postgres and non-transactional Mongo always bump shard 0. Readers sum across shards.
+*
+* When `transactionID` names an open Payload transaction, the write joins it: a bump failure
+* thrown from the submission hook rolls back the submission create (no undercount), and an
+* aborted create rolls back the joined bump (no overcount). Residual risk on transactional
+* Mongo: two concurrent bumps that land on the same shard still abort one transaction
+* (WriteConflict, labelled TransientTransactionError); the losing submission rolls back whole,
+* so counts stay consistent and the client can safely resubmit. Without a transaction (e.g.
+* Mongo with transactions disabled) the write lands on the root handle immediately; a later
+* recount from stored submissions is the healer for any drift that window allows.
+*/
+async function bumpPollVote(payload, key, by, transactionID) {
+	if (payload.db.name === "mongoose") {
+		const db = payload.db;
+		const model = db.collections[POLL_VOTES_SLUG];
+		if (!model) throw new Error(`form-builder: mongoose collection "${POLL_VOTES_SLUG}" not found`);
+		const session = transactionID !== void 0 ? db.sessions?.[transactionID] : void 0;
+		const shard = session ? Math.floor(Math.random() * 8) : 0;
+		const shardedKey = {
+			...key,
+			shard
+		};
+		const update = {
+			$inc: { count: by },
+			$setOnInsert: shardedKey
+		};
+		const options = session ? {
+			upsert: true,
+			session
+		} : { upsert: true };
+		try {
+			await model.collection.updateOne(shardedKey, update, options);
+		} catch (error) {
+			const duplicate = error?.code === 11e3;
+			if (session || !duplicate) throw error;
+			await model.collection.updateOne(shardedKey, update, options);
+		}
+		return;
+	}
+	const { sql } = await importPostgresSql();
+	const db = payload.db;
+	const tableName = db.tableNameMap.get(PG_TABLE_KEY);
+	if (!tableName) throw new Error(`form-builder: drizzle table "${PG_TABLE_KEY}" not found`);
+	const table = db.tables[tableName];
+	if (!table) throw new Error(`form-builder: drizzle table object for "${tableName}" not found`);
+	await ((transactionID !== void 0 ? db.sessions?.[transactionID]?.db : void 0) ?? db.drizzle).insert(table).values({
+		...key,
+		shard: 0,
+		count: by
+	}).onConflictDoUpdate({
+		target: [
+			table.form,
+			table.field,
+			table.value,
+			table.shard
+		],
+		set: { count: sql`${table.count} + ${by}` }
+	});
+}
+//#endregion
+export { bumpPollVote };
+
+//# sourceMappingURL=bumpPollVote.js.map

package/dist/poll/votes/bumpPollVote.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bumpPollVote.js","names":[],"sources":["../../../src/poll/votes/bumpPollVote.ts"],"sourcesContent":["import type { Payload } from 'payload'\nimport { POLL_VOTES_SLUG, VOTE_SHARDS } from './votesCollection'\n\nconst PG_TABLE_KEY = 'form_poll_votes'\n\ntype PostgresSqlModule = { sql: typeof import('@payloadcms/db-postgres')['sql'] }\n\n/**\n * Loads the optional Postgres peer without a literal specifier: bundlers (Turbopack, webpack,\n * Vite) resolve literal dynamic imports at build time, which fails a Mongo host's build even\n * though this branch is unreachable there. The function-built specifier is opaque to their\n * analyzers, the ignore comments cover bundlers that would still warn, and the type-only\n * reference above erases at compile time, so the package is touched only when the Postgres\n * branch actually runs.\n */\nconst importPostgresSql = (): Promise<PostgresSqlModule> => {\n\tconst specifier = ['@payloadcms', 'db-postgres'].join('/')\n\treturn import(\n\t\t/* webpackIgnore: true */ /* turbopackIgnore: true */ /* @vite-ignore */ specifier\n\t) as Promise<PostgresSqlModule>\n}\n\n// payload.db raw-access shapes are intentionally loose; these narrow casts reach the\n// Mongoose driver collection / Drizzle instance for atomic upserts (no public typed API).\ntype MongoDb = {\n\tname: 'mongoose'\n\tcollections: Record<\n\t\tstring,\n\t\t{ collection: { updateOne: (f: object, u: object, o: object) => Promise<unknown> } }\n\t>\n\tsessions?: Record<number | string, unknown>\n}\ntype PgInsert = {\n\tinsert: (t: unknown) => {\n\t\tvalues: (v: unknown) => { onConflictDoUpdate: (c: unknown) => Promise<unknown> }\n\t}\n}\ntype PgDb = {\n\tname: 'postgres'\n\tdrizzle: PgInsert\n\tsessions?: Record<number | string, { db: PgInsert }>\n\ttables: Record<string, Record<string, unknown>>\n\ttableNameMap: Map<string, string>\n}\n\n/**\n * Atomically bumps one (form, field, value) tally by `by` in a single upsert-increment\n * statement (Mongo `$inc` + upsert, Postgres `INSERT ... ON CONFLICT DO UPDATE`); the unique\n * compound index makes concurrent bumps for the same key safe without read-modify-write races.\n * The shard column is internal: transactional Mongo bumps pick a random shard in\n * [0, VOTE_SHARDS) so concurrent transactions rarely write the same document (see VOTE_SHARDS);\n * Postgres and non-transactional Mongo always bump shard 0. Readers sum across shards.\n *\n * When `transactionID` names an open Payload transaction, the write joins it: a bump failure\n * thrown from the submission hook rolls back the submission create (no undercount), and an\n * aborted create rolls back the joined bump (no overcount). Residual risk on transactional\n * Mongo: two concurrent bumps that land on the same shard still abort one transaction\n * (WriteConflict, labelled TransientTransactionError); the losing submission rolls back whole,\n * so counts stay consistent and the client can safely resubmit. Without a transaction (e.g.\n * Mongo with transactions disabled) the write lands on the root handle immediately; a later\n * recount from stored submissions is the healer for any drift that window allows.\n */\n// biome-ignore lint/complexity/useMaxParams: write primitive signature (payload, key, by, transactionID)\nexport async function bumpPollVote(\n\tpayload: Payload,\n\tkey: { form: string; field: string; value: string },\n\tby: number,\n\ttransactionID?: number | string\n): Promise<void> {\n\tif (payload.db.name === 'mongoose') {\n\t\tconst db = payload.db as unknown as MongoDb\n\t\tconst model = db.collections[POLL_VOTES_SLUG]\n\t\tif (!model) throw new Error(`form-builder: mongoose collection \"${POLL_VOTES_SLUG}\" not found`)\n\t\tconst session = transactionID !== undefined ? db.sessions?.[transactionID] : undefined\n\t\tconst shard = session ? Math.floor(Math.random() * VOTE_SHARDS) : 0\n\t\tconst shardedKey = { ...key, shard }\n\t\tconst update = { $inc: { count: by }, $setOnInsert: shardedKey }\n\t\tconst options = session ? { upsert: true, session } : { upsert: true }\n\t\ttry {\n\t\t\tawait model.collection.updateOne(shardedKey, update, options)\n\t\t} catch (error) {\n\t\t\t// Concurrent first inserts for a new key can race the upsert into E11000; outside a\n\t\t\t// transaction the row now exists, so one retry takes the $inc branch. Inside a\n\t\t\t// transaction the error propagates and Payload's rollback/retry semantics apply.\n\t\t\tconst duplicate = (error as { code?: unknown } | null)?.code === 11000\n\t\t\tif (session || !duplicate) throw error\n\t\t\tawait model.collection.updateOne(shardedKey, update, options)\n\t\t}\n\t\treturn\n\t}\n\tconst { sql } = await importPostgresSql()\n\tconst db = payload.db as unknown as PgDb\n\tconst tableName = db.tableNameMap.get(PG_TABLE_KEY)\n\tif (!tableName) throw new Error(`form-builder: drizzle table \"${PG_TABLE_KEY}\" not found`)\n\tconst table = db.tables[tableName]\n\tif (!table) throw new Error(`form-builder: drizzle table object for \"${tableName}\" not found`)\n\tconst txn = transactionID !== undefined ? db.sessions?.[transactionID]?.db : undefined\n\tawait (txn ?? db.drizzle)\n\t\t.insert(table)\n\t\t.values({ ...key, shard: 0, count: by })\n\t\t.onConflictDoUpdate({\n\t\t\ttarget: [table.form, table.field, table.value, table.shard],\n\t\t\tset: { count: sql`${table.count} + ${by}` },\n\t\t})\n}\n"],"mappings":";;AAGA,MAAM,eAAe;;;;;;;;;AAYrB,MAAM,0BAAsD;CAE3D,OAAO;;;;EADW,CAAC,eAAe,aAAa,EAAE,KAAK,GAE4B;;AAEnF;;;;;;;;;;;;;;;;;;AA2CA,eAAsB,aACrB,SACA,KACA,IACA,eACgB;CAChB,IAAI,QAAQ,GAAG,SAAS,YAAY;EACnC,MAAM,KAAK,QAAQ;EACnB,MAAM,QAAQ,GAAG,YAAY;EAC7B,IAAI,CAAC,OAAO,MAAM,IAAI,MAAM,sCAAsC,gBAAgB,YAAY;EAC9F,MAAM,UAAU,kBAAkB,KAAA,IAAY,GAAG,WAAW,iBAAiB,KAAA;EAC7E,MAAM,QAAQ,UAAU,KAAK,MAAM,KAAK,OAAO,IAAA,CAAe,IAAI;EAClE,MAAM,aAAa;GAAE,GAAG;GAAK;EAAM;EACnC,MAAM,SAAS;GAAE,MAAM,EAAE,OAAO,GAAG;GAAG,cAAc;EAAW;EAC/D,MAAM,UAAU,UAAU;GAAE,QAAQ;GAAM;EAAQ,IAAI,EAAE,QAAQ,KAAK;EACrE,IAAI;GACH,MAAM,MAAM,WAAW,UAAU,YAAY,QAAQ,OAAO;EAC7D,SAAS,OAAO;GAIf,MAAM,YAAa,OAAqC,SAAS;GACjE,IAAI,WAAW,CAAC,WAAW,MAAM;GACjC,MAAM,MAAM,WAAW,UAAU,YAAY,QAAQ,OAAO;EAC7D;EACA;CACD;CACA,MAAM,EAAE,QAAQ,MAAM,kBAAkB;CACxC,MAAM,KAAK,QAAQ;CACnB,MAAM,YAAY,GAAG,aAAa,IAAI,YAAY;CAClD,IAAI,CAAC,WAAW,MAAM,IAAI,MAAM,gCAAgC,aAAa,YAAY;CACzF,MAAM,QAAQ,GAAG,OAAO;CACxB,IAAI,CAAC,OAAO,MAAM,IAAI,MAAM,2CAA2C,UAAU,YAAY;CAE7F,QADY,kBAAkB,KAAA,IAAY,GAAG,WAAW,gBAAgB,KAAK,KAAA,MAC/D,GAAG,SACf,OAAO,KAAK,EACZ,OAAO;EAAE,GAAG;EAAK,OAAO;EAAG,OAAO;CAAG,CAAC,EACtC,mBAAmB;EACnB,QAAQ;GAAC,MAAM;GAAM,MAAM;GAAO,MAAM;GAAO,MAAM;EAAK;EAC1D,KAAK,EAAE,OAAO,GAAG,GAAG,MAAM,MAAM,KAAK,KAAK;CAC3C,CAAC;AACH"}

package/dist/poll/votes/recountPollVotes.d.ts

@@ -0,0 +1,20 @@
+import { Payload, PayloadRequest } from "payload";
+
+//#region src/poll/votes/recountPollVotes.d.ts
+/**
+ * Rebuild a form's tally rows from persisted submissions (drift healing after out-of-band DB
+ * changes, or backfill after enabling a poll late). Scans first and refuses a truncated
+ * aggregation, then deletes the form's tally rows for the results field and replays the scan
+ * into fresh rows, so the store is never left holding a knowingly partial count. Writes join
+ * the request's transaction when one is open. Refuses a form with `persistSubmissions` off:
+ * its submissions are pruned, so the tally store is the only record of its votes and a rebuild
+ * would wipe them.
+ */
+declare const recountPollVotes: (args: {
+  payload: Payload;
+  formId: number | string;
+  req?: PayloadRequest;
+}) => Promise<void>;
+//#endregion
+export { recountPollVotes };
+//# sourceMappingURL=recountPollVotes.d.ts.map

package/dist/poll/votes/recountPollVotes.js

@@ -0,0 +1,63 @@
+import { pollConfigOf } from "../../form/pollState.js";
+import { aggregateFieldResponses } from "../../aggregation/aggregateResponses.js";
+import { POLL_VOTES_SLUG } from "./votesCollection.js";
+import { FORMS_SLUG } from "../../collections/forms.js";
+import { bumpPollVote } from "./bumpPollVote.js";
+import { transactionIDOf } from "./voteTallyHook.js";
+//#region src/poll/votes/recountPollVotes.ts
+const RECOUNT_MAX_SUBMISSIONS = 1e5;
+/**
+* Rebuild a form's tally rows from persisted submissions (drift healing after out-of-band DB
+* changes, or backfill after enabling a poll late). Scans first and refuses a truncated
+* aggregation, then deletes the form's tally rows for the results field and replays the scan
+* into fresh rows, so the store is never left holding a knowingly partial count. Writes join
+* the request's transaction when one is open. Refuses a form with `persistSubmissions` off:
+* its submissions are pruned, so the tally store is the only record of its votes and a rebuild
+* would wipe them.
+*/
+const recountPollVotes = async (args) => {
+	const { payload, formId, req } = args;
+	const form = await payload.findByID({
+		collection: FORMS_SLUG,
+		id: formId,
+		depth: 0,
+		overrideAccess: true,
+		req
+	}).catch(() => null);
+	const poll = form ? pollConfigOf(form.poll) : void 0;
+	const resultsField = typeof poll?.resultsField === "string" && poll.resultsField.length > 0 ? poll.resultsField : void 0;
+	if (!resultsField) return;
+	if (form?.persistSubmissions === false) throw new Error(`form-builder: recountPollVotes cannot rebuild form "${String(formId)}": it does not persist submissions, so the tally store is the only record of its votes.`);
+	const aggregation = await aggregateFieldResponses({
+		payload,
+		formId,
+		field: resultsField,
+		req,
+		maxSubmissions: RECOUNT_MAX_SUBMISSIONS
+	});
+	if (aggregation?.truncated) throw new Error(`form-builder: recount for form ${String(formId)} aborted: more than ${RECOUNT_MAX_SUBMISSIONS} submissions, the scan was truncated and a rebuilt tally would be partial.`);
+	await payload.delete({
+		collection: POLL_VOTES_SLUG,
+		where: { and: [{ form: { equals: String(formId) } }, { field: { equals: resultsField } }] },
+		overrideAccess: true,
+		req
+	});
+	if (!aggregation) return;
+	const transactionID = transactionIDOf(req?.transactionID);
+	const base = {
+		form: String(formId),
+		field: resultsField
+	};
+	for (const bucket of aggregation.buckets) if (bucket.count > 0) await bumpPollVote(payload, {
+		...base,
+		value: bucket.value
+	}, bucket.count, transactionID);
+	if (aggregation.total > 0) await bumpPollVote(payload, {
+		...base,
+		value: ""
+	}, aggregation.total, transactionID);
+};
+//#endregion
+export { recountPollVotes };
+
+//# sourceMappingURL=recountPollVotes.js.map

package/dist/poll/votes/recountPollVotes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"recountPollVotes.js","names":[],"sources":["../../../src/poll/votes/recountPollVotes.ts"],"sourcesContent":["import type { Payload, PayloadRequest } from 'payload'\nimport { aggregateFieldResponses } from '../../aggregation/aggregateResponses'\nimport { FORMS_SLUG } from '../../collections/forms'\nimport { pollConfigOf } from '../../form/pollState'\nimport { bumpPollVote } from './bumpPollVote'\nimport { POLL_VOTES_SLUG, RESPONDENTS_VALUE } from './votesCollection'\nimport { transactionIDOf } from './voteTallyHook'\n\nconst RECOUNT_MAX_SUBMISSIONS = 100_000\n\n/**\n * Rebuild a form's tally rows from persisted submissions (drift healing after out-of-band DB\n * changes, or backfill after enabling a poll late). Scans first and refuses a truncated\n * aggregation, then deletes the form's tally rows for the results field and replays the scan\n * into fresh rows, so the store is never left holding a knowingly partial count. Writes join\n * the request's transaction when one is open. Refuses a form with `persistSubmissions` off:\n * its submissions are pruned, so the tally store is the only record of its votes and a rebuild\n * would wipe them.\n */\nexport const recountPollVotes = async (args: {\n\tpayload: Payload\n\tformId: number | string\n\treq?: PayloadRequest\n}): Promise<void> => {\n\tconst { payload, formId, req } = args\n\tconst form = await payload\n\t\t.findByID({ collection: FORMS_SLUG, id: formId, depth: 0, overrideAccess: true, req })\n\t\t.catch(() => null)\n\tconst poll = form ? pollConfigOf(form.poll) : undefined\n\tconst resultsField =\n\t\ttypeof poll?.resultsField === 'string' && poll.resultsField.length > 0\n\t\t\t? poll.resultsField\n\t\t\t: undefined\n\tif (!resultsField) {\n\t\treturn\n\t}\n\tif (form?.persistSubmissions === false) {\n\t\tthrow new Error(\n\t\t\t`form-builder: recountPollVotes cannot rebuild form \"${String(formId)}\": it does not persist submissions, so the tally store is the only record of its votes.`\n\t\t)\n\t}\n\tconst aggregation = await aggregateFieldResponses({\n\t\tpayload,\n\t\tformId,\n\t\tfield: resultsField,\n\t\treq,\n\t\tmaxSubmissions: RECOUNT_MAX_SUBMISSIONS,\n\t})\n\tif (aggregation?.truncated) {\n\t\tthrow new Error(\n\t\t\t`form-builder: recount for form ${String(formId)} aborted: more than ${RECOUNT_MAX_SUBMISSIONS} submissions, the scan was truncated and a rebuilt tally would be partial.`\n\t\t)\n\t}\n\tawait payload.delete({\n\t\tcollection: POLL_VOTES_SLUG,\n\t\twhere: {\n\t\t\tand: [{ form: { equals: String(formId) } }, { field: { equals: resultsField } }],\n\t\t},\n\t\toverrideAccess: true,\n\t\treq,\n\t})\n\tif (!aggregation) {\n\t\treturn\n\t}\n\tconst transactionID = transactionIDOf(req?.transactionID)\n\tconst base = { form: String(formId), field: resultsField }\n\tfor (const bucket of aggregation.buckets) {\n\t\tif (bucket.count > 0) {\n\t\t\tawait bumpPollVote(payload, { ...base, value: bucket.value }, bucket.count, transactionID)\n\t\t}\n\t}\n\tif (aggregation.total > 0) {\n\t\tawait bumpPollVote(\n\t\t\tpayload,\n\t\t\t{ ...base, value: RESPONDENTS_VALUE },\n\t\t\taggregation.total,\n\t\t\ttransactionID\n\t\t)\n\t}\n}\n"],"mappings":";;;;;;;AAQA,MAAM,0BAA0B;;;;;;;;;;AAWhC,MAAa,mBAAmB,OAAO,SAIlB;CACpB,MAAM,EAAE,SAAS,QAAQ,QAAQ;CACjC,MAAM,OAAO,MAAM,QACjB,SAAS;EAAE,YAAY;EAAY,IAAI;EAAQ,OAAO;EAAG,gBAAgB;EAAM;CAAI,CAAC,EACpF,YAAY,IAAI;CAClB,MAAM,OAAO,OAAO,aAAa,KAAK,IAAI,IAAI,KAAA;CAC9C,MAAM,eACL,OAAO,MAAM,iBAAiB,YAAY,KAAK,aAAa,SAAS,IAClE,KAAK,eACL,KAAA;CACJ,IAAI,CAAC,cACJ;CAED,IAAI,MAAM,uBAAuB,OAChC,MAAM,IAAI,MACT,uDAAuD,OAAO,MAAM,EAAE,wFACvE;CAED,MAAM,cAAc,MAAM,wBAAwB;EACjD;EACA;EACA,OAAO;EACP;EACA,gBAAgB;CACjB,CAAC;CACD,IAAI,aAAa,WAChB,MAAM,IAAI,MACT,kCAAkC,OAAO,MAAM,EAAE,sBAAsB,wBAAwB,2EAChG;CAED,MAAM,QAAQ,OAAO;EACpB,YAAY;EACZ,OAAO,EACN,KAAK,CAAC,EAAE,MAAM,EAAE,QAAQ,OAAO,MAAM,EAAE,EAAE,GAAG,EAAE,OAAO,EAAE,QAAQ,aAAa,EAAE,CAAC,EAChF;EACA,gBAAgB;EAChB;CACD,CAAC;CACD,IAAI,CAAC,aACJ;CAED,MAAM,gBAAgB,gBAAgB,KAAK,aAAa;CACxD,MAAM,OAAO;EAAE,MAAM,OAAO,MAAM;EAAG,OAAO;CAAa;CACzD,KAAK,MAAM,UAAU,YAAY,SAChC,IAAI,OAAO,QAAQ,GAClB,MAAM,aAAa,SAAS;EAAE,GAAG;EAAM,OAAO,OAAO;CAAM,GAAG,OAAO,OAAO,aAAa;CAG3F,IAAI,YAAY,QAAQ,GACvB,MAAM,aACL,SACA;EAAE,GAAG;EAAM,OAAA;CAAyB,GACpC,YAAY,OACZ,aACD;AAEF"}

package/dist/poll/votes/voteTallyHook.js

@@ -0,0 +1,76 @@
+import { pollConfigOf } from "../../form/pollState.js";
+import "./votesCollection.js";
+import { FORMS_SLUG } from "../../collections/forms.js";
+import { formIdOf } from "../../submissions/formIdOf.js";
+import { answerValues } from "./answerValues.js";
+import { bumpPollVote } from "./bumpPollVote.js";
+//#region src/poll/votes/voteTallyHook.ts
+const isComplete = (doc) => doc.status == null || doc.status === "complete";
+/** Narrow a request's loosely typed `transactionID` to the value `bumpPollVote` accepts. */
+const transactionIDOf = (transactionID) => typeof transactionID === "number" || typeof transactionID === "string" ? transactionID : void 0;
+/**
+* Vote counting: a submission entering `complete` bumps one tally per answer value for the poll
+* results field, plus the shared respondents row. Votes are permanent by default: no decrement on
+* delete, edit, or prune, which is what lets a pruned submission's vote survive. The one
+* exception is an `allowChange` poll, where an update of an already-complete submission moves the
+* tally with the changed answer (decrement removed values, increment added ones, respondents
+* untouched); delete and prune stay permanent even then. Two concurrent changes of the same
+* submission can each read the same previous answer and double-adjust; the client's double-submit
+* guard makes that rare and `recountPollVotes` is the healer, matching `bumpPollVote`'s residual
+* drift note. Bump failures propagate so the enclosing transaction rolls the submission back
+* rather than silently undercounting; registered before the swallow-all dispatch hook.
+*/
+const makeVoteTallyHook = () => async ({ doc, previousDoc, operation, req }) => {
+	if (operation !== "create" && operation !== "update") return doc;
+	const entering = operation === "create" && isComplete(doc) || operation === "update" && isComplete(doc) && !isComplete(previousDoc ?? {});
+	const changing = operation === "update" && isComplete(doc) && isComplete(previousDoc ?? {}) && !entering;
+	if (!entering && !changing) return doc;
+	const formId = formIdOf(doc.form);
+	if (formId == null) return doc;
+	const form = await req.payload.findByID({
+		collection: FORMS_SLUG,
+		id: formId,
+		depth: 0,
+		overrideAccess: true,
+		req
+	}).catch(() => null);
+	const poll = form?.pollEnabled === true ? pollConfigOf(form.poll) : void 0;
+	const resultsField = typeof poll?.resultsField === "string" && poll.resultsField.length > 0 ? poll.resultsField : void 0;
+	if (!resultsField) return doc;
+	const transactionID = transactionIDOf(req.transactionID);
+	const base = {
+		form: String(formId),
+		field: resultsField
+	};
+	if (changing) {
+		if (poll?.allowChange !== true) return doc;
+		const previous = answerValues(previousDoc?.values, resultsField);
+		const next = answerValues(doc.values, resultsField);
+		const removed = previous.filter((value) => !next.includes(value));
+		const added = next.filter((value) => !previous.includes(value));
+		for (const value of removed) await bumpPollVote(req.payload, {
+			...base,
+			value
+		}, -1, transactionID);
+		for (const value of added) await bumpPollVote(req.payload, {
+			...base,
+			value
+		}, 1, transactionID);
+		return doc;
+	}
+	const votes = answerValues(doc.values, resultsField);
+	if (votes.length === 0) return doc;
+	for (const value of votes) await bumpPollVote(req.payload, {
+		...base,
+		value
+	}, 1, transactionID);
+	await bumpPollVote(req.payload, {
+		...base,
+		value: ""
+	}, 1, transactionID);
+	return doc;
+};
+//#endregion
+export { makeVoteTallyHook, transactionIDOf };
+
+//# sourceMappingURL=voteTallyHook.js.map

package/dist/poll/votes/voteTallyHook.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"voteTallyHook.js","names":[],"sources":["../../../src/poll/votes/voteTallyHook.ts"],"sourcesContent":["import type { CollectionAfterChangeHook } from 'payload'\nimport { FORMS_SLUG } from '../../collections/forms'\nimport { pollConfigOf } from '../../form/pollState'\nimport { formIdOf } from '../../submissions/formIdOf'\nimport { answerValues } from './answerValues'\nimport { bumpPollVote } from './bumpPollVote'\nimport { RESPONDENTS_VALUE } from './votesCollection'\n\nconst isComplete = (doc: { status?: unknown }): boolean =>\n\tdoc.status == null || doc.status === 'complete'\n\n/** Narrow a request's loosely typed `transactionID` to the value `bumpPollVote` accepts. */\nexport const transactionIDOf = (transactionID: unknown): number | string | undefined =>\n\ttypeof transactionID === 'number' || typeof transactionID === 'string' ? transactionID : undefined\n\n/**\n * Vote counting: a submission entering `complete` bumps one tally per answer value for the poll\n * results field, plus the shared respondents row. Votes are permanent by default: no decrement on\n * delete, edit, or prune, which is what lets a pruned submission's vote survive. The one\n * exception is an `allowChange` poll, where an update of an already-complete submission moves the\n * tally with the changed answer (decrement removed values, increment added ones, respondents\n * untouched); delete and prune stay permanent even then. Two concurrent changes of the same\n * submission can each read the same previous answer and double-adjust; the client's double-submit\n * guard makes that rare and `recountPollVotes` is the healer, matching `bumpPollVote`'s residual\n * drift note. Bump failures propagate so the enclosing transaction rolls the submission back\n * rather than silently undercounting; registered before the swallow-all dispatch hook.\n */\nexport const makeVoteTallyHook =\n\t(): CollectionAfterChangeHook =>\n\tasync ({ doc, previousDoc, operation, req }) => {\n\t\tif (operation !== 'create' && operation !== 'update') return doc\n\t\tconst entering =\n\t\t\t(operation === 'create' && isComplete(doc)) ||\n\t\t\t(operation === 'update' && isComplete(doc) && !isComplete(previousDoc ?? {}))\n\t\tconst changing =\n\t\t\toperation === 'update' && isComplete(doc) && isComplete(previousDoc ?? {}) && !entering\n\t\tif (!entering && !changing) return doc\n\t\tconst formId = formIdOf(doc.form)\n\t\tif (formId == null) return doc\n\t\tconst form = await req.payload\n\t\t\t.findByID({ collection: FORMS_SLUG, id: formId, depth: 0, overrideAccess: true, req })\n\t\t\t.catch(() => null)\n\t\tconst poll = form?.pollEnabled === true ? pollConfigOf(form.poll) : undefined\n\t\tconst resultsField =\n\t\t\ttypeof poll?.resultsField === 'string' && poll.resultsField.length > 0\n\t\t\t\t? poll.resultsField\n\t\t\t\t: undefined\n\t\tif (!resultsField) return doc\n\t\tconst transactionID = transactionIDOf(req.transactionID)\n\t\tconst base = { form: String(formId), field: resultsField }\n\t\tif (changing) {\n\t\t\tif (poll?.allowChange !== true) return doc\n\t\t\tconst previous = answerValues(previousDoc?.values, resultsField)\n\t\t\tconst next = answerValues(doc.values, resultsField)\n\t\t\tconst removed = previous.filter((value) => !next.includes(value))\n\t\t\tconst added = next.filter((value) => !previous.includes(value))\n\t\t\tfor (const value of removed) {\n\t\t\t\tawait bumpPollVote(req.payload, { ...base, value }, -1, transactionID)\n\t\t\t}\n\t\t\tfor (const value of added) {\n\t\t\t\tawait bumpPollVote(req.payload, { ...base, value }, 1, transactionID)\n\t\t\t}\n\t\t\treturn doc\n\t\t}\n\t\tconst votes = answerValues(doc.values, resultsField)\n\t\tif (votes.length === 0) return doc\n\t\tfor (const value of votes) {\n\t\t\tawait bumpPollVote(req.payload, { ...base, value }, 1, transactionID)\n\t\t}\n\t\tawait bumpPollVote(req.payload, { ...base, value: RESPONDENTS_VALUE }, 1, transactionID)\n\t\treturn doc\n\t}\n"],"mappings":";;;;;;;AAQA,MAAM,cAAc,QACnB,IAAI,UAAU,QAAQ,IAAI,WAAW;;AAGtC,MAAa,mBAAmB,kBAC/B,OAAO,kBAAkB,YAAY,OAAO,kBAAkB,WAAW,gBAAgB,KAAA;;;;;;;;;;;;;AAc1F,MAAa,0BAEZ,OAAO,EAAE,KAAK,aAAa,WAAW,UAAU;CAC/C,IAAI,cAAc,YAAY,cAAc,UAAU,OAAO;CAC7D,MAAM,WACJ,cAAc,YAAY,WAAW,GAAG,KACxC,cAAc,YAAY,WAAW,GAAG,KAAK,CAAC,WAAW,eAAe,CAAC,CAAC;CAC5E,MAAM,WACL,cAAc,YAAY,WAAW,GAAG,KAAK,WAAW,eAAe,CAAC,CAAC,KAAK,CAAC;CAChF,IAAI,CAAC,YAAY,CAAC,UAAU,OAAO;CACnC,MAAM,SAAS,SAAS,IAAI,IAAI;CAChC,IAAI,UAAU,MAAM,OAAO;CAC3B,MAAM,OAAO,MAAM,IAAI,QACrB,SAAS;EAAE,YAAY;EAAY,IAAI;EAAQ,OAAO;EAAG,gBAAgB;EAAM;CAAI,CAAC,EACpF,YAAY,IAAI;CAClB,MAAM,OAAO,MAAM,gBAAgB,OAAO,aAAa,KAAK,IAAI,IAAI,KAAA;CACpE,MAAM,eACL,OAAO,MAAM,iBAAiB,YAAY,KAAK,aAAa,SAAS,IAClE,KAAK,eACL,KAAA;CACJ,IAAI,CAAC,cAAc,OAAO;CAC1B,MAAM,gBAAgB,gBAAgB,IAAI,aAAa;CACvD,MAAM,OAAO;EAAE,MAAM,OAAO,MAAM;EAAG,OAAO;CAAa;CACzD,IAAI,UAAU;EACb,IAAI,MAAM,gBAAgB,MAAM,OAAO;EACvC,MAAM,WAAW,aAAa,aAAa,QAAQ,YAAY;EAC/D,MAAM,OAAO,aAAa,IAAI,QAAQ,YAAY;EAClD,MAAM,UAAU,SAAS,QAAQ,UAAU,CAAC,KAAK,SAAS,KAAK,CAAC;EAChE,MAAM,QAAQ,KAAK,QAAQ,UAAU,CAAC,SAAS,SAAS,KAAK,CAAC;EAC9D,KAAK,MAAM,SAAS,SACnB,MAAM,aAAa,IAAI,SAAS;GAAE,GAAG;GAAM;EAAM,GAAG,IAAI,aAAa;EAEtE,KAAK,MAAM,SAAS,OACnB,MAAM,aAAa,IAAI,SAAS;GAAE,GAAG;GAAM;EAAM,GAAG,GAAG,aAAa;EAErE,OAAO;CACR;CACA,MAAM,QAAQ,aAAa,IAAI,QAAQ,YAAY;CACnD,IAAI,MAAM,WAAW,GAAG,OAAO;CAC/B,KAAK,MAAM,SAAS,OACnB,MAAM,aAAa,IAAI,SAAS;EAAE,GAAG;EAAM;CAAM,GAAG,GAAG,aAAa;CAErE,MAAM,aAAa,IAAI,SAAS;EAAE,GAAG;EAAM,OAAA;CAAyB,GAAG,GAAG,aAAa;CACvF,OAAO;AACR"}

package/dist/poll/votes/votesCollection.d.ts

@@ -0,0 +1,19 @@
+import { CollectionConfig } from "payload";
+
+//#region src/poll/votes/votesCollection.d.ts
+declare const POLL_VOTES_SLUG = "form-poll-votes";
+/** Reserved tally `value` marking the per-field respondents counter (empty answers are never counted, so '' is free). */
+declare const RESPONDENTS_VALUE = "";
+/**
+ * Shard count for hot tally counters. Mongo aborts one of two transactions that write the same
+ * document (WriteConflict/TransientTransactionError), so concurrent transactional votes for the
+ * same (form, field, value) would deterministically fail one submission. Spreading each
+ * transactional bump across VOTE_SHARDS rows makes concurrent bumps land on different shards
+ * with high probability, so transactions stop contending. Postgres row locks serialize
+ * ON CONFLICT updates without aborting and non-transactional Mongo $inc is conflict-free, so
+ * both always use shard 0. Reads sum counts across shards.
+ */
+declare const VOTE_SHARDS = 8;
+//#endregion
+export { POLL_VOTES_SLUG, RESPONDENTS_VALUE, VOTE_SHARDS };
+//# sourceMappingURL=votesCollection.d.ts.map