teqo-backup/src/utilities/votePledgeData.ts
Francisco Ignácio Fontoura Solla 162d4c10fe perf(campanha): roda as funções em gru1 e encurta o waterfall de queries
As funções rodavam no default iad1 (Virgínia) enquanto o Neon fica em
sa-east-1 (São Paulo): cada query do Payload atravessava o equador duas
vezes (~120 ms por ida-e-volta) e uma página do /campanha faz uma dúzia.
Medido em produção: 410-470 ms de TTFB para um 307 que não toca o banco.

- vercel.json fixa regions: [gru1], mesma região AWS do banco (Hobby
  permite uma região, mas permite escolher qual).
- loadStatewideSuggestedGoals passa a ser exportada e é disparada dentro
  do Promise.all que já lê o escopo, na lista e no dashboard: o read do
  global campaignGoals saía sozinho no fim da requisição.
- loadMunicipalityScope lê os pledges em paralelo quando o ator é
  irrestrito e não há filtro (aí o IN de 435 ids não exclui nada);
  qualquer escopo mais estreito continua esperando os ids.

Débitos medidos no caminho e registrados em TECH-DEBT: o fan-out de
leituras do ator em getFreshCampaignUser (~5 por render) e a leitura
dupla em authenticateCampaignToken.
2026-07-26 21:00:06 -03:00

159 lines
5.2 KiB
TypeScript

import 'server-only'
import type { Payload, PayloadRequest, Where } from 'payload'
import {
effectivePledgeVotesForScenario,
toVoteEstimateScenarioViewModel,
VOTE_ESTIMATE_SCENARIOS,
} from '@/lib/voteEstimate'
import type { CampaignUser, VotePledge } from '@/payload-types'
import { latestIsoTimestamp } from '@/utilities/campaignTime'
import { relationshipId, requireRelationshipId } from '@/utilities/relationship'
import {
createEmptyMunicipalityPledgeAggregate,
pledgeHasAnyEstimate,
type MunicipalityPledgeAggregate,
type StaffPledgeRow,
} from '@/utilities/votePledgeViews'
/**
* Pledge Payload READS. The pure aggregation math and view models live in
* `votePledgeViews.ts` (client-safe contract module).
*/
/**
* Staff-only aggregate over an already access-checked municipality id set.
* Intentional admin bypass: callers pass municipality ids the actor may read.
*/
export const aggregatePledgesByMunicipality = async (
payload: Pick<Payload, 'find'>,
municipalityIDs: number[],
req?: PayloadRequest,
): Promise<Map<number, MunicipalityPledgeAggregate>> => {
if (municipalityIDs.length === 0) return new Map()
return aggregatePledgesWhere(payload, { municipality: { in: municipalityIDs } }, req)
}
/**
* The same aggregate over EVERY pledge, for a caller whose município scope is
* the whole catalog: there `municipality IN (…)` excludes nothing, so dropping
* it lets the pledge read leave in the same round trip as the município read
* instead of waiting for its ids (and drops a 435-element IN list). Keys the
* caller doesn't know are harmless — every consumer looks the map up by
* município id, none iterates it.
*/
export const aggregateAllPledgesByMunicipality = (
payload: Pick<Payload, 'find'>,
req?: PayloadRequest,
): Promise<Map<number, MunicipalityPledgeAggregate>> => aggregatePledgesWhere(payload, {}, req)
const aggregatePledgesWhere = async (
payload: Pick<Payload, 'find'>,
where: Where,
req?: PayloadRequest,
): Promise<Map<number, MunicipalityPledgeAggregate>> => {
const aggregates = new Map<number, MunicipalityPledgeAggregate>()
const result = await payload.find({
collection: 'votePledge',
where,
depth: 0,
limit: 0,
pagination: false,
select: {
municipality: true,
declaredVotes: true,
estimatedVotes: {
pessimistic: true,
central: true,
optimistic: true,
},
// E9 freshness (`lastPledgeAt`) — the queue orders by how cold the signal is.
declaredAt: true,
estimatedAt: true,
},
overrideAccess: true,
...(req ? { req } : {}),
})
for (const doc of result.docs) {
// `select` narrows the runtime shape, not the static type Payload returns.
const pledge = doc as VotePledge
const municipalityID = relationshipId(pledge.municipality)
if (municipalityID === null) continue
const declared = pledge.declaredVotes ?? 0
const estimated = pledge.estimatedVotes
const current = aggregates.get(municipalityID) ?? createEmptyMunicipalityPledgeAggregate()
current.declaredTotal += declared
for (const scenario of VOTE_ESTIMATE_SCENARIOS) {
current.effectiveByScenario[scenario] += effectivePledgeVotesForScenario(
declared,
estimated,
scenario,
)
}
current.pledgeCount += 1
if (!pledgeHasAnyEstimate(estimated)) current.missingEstimateCount += 1
current.lastPledgeAt = latestIsoTimestamp(
current.lastPledgeAt,
latestIsoTimestamp(pledge.declaredAt, pledge.estimatedAt),
)
aggregates.set(municipalityID, current)
}
return aggregates
}
/** Staff view of a municipality's pledges with leadership contact names. */
export const loadMunicipalityPledges = async (
payload: Payload,
user: CampaignUser,
municipalityID: number,
): Promise<StaffPledgeRow[]> => {
const pledges = await payload.find({
collection: 'votePledge',
where: { municipality: { equals: municipalityID } },
depth: 0,
limit: 0,
pagination: false,
sort: '-declaredVotes',
user,
overrideAccess: false,
})
if (pledges.docs.length === 0) return []
const leadershipIDs = [
...new Set(pledges.docs.map((pledge) => requireRelationshipId(pledge.leadership))),
]
const leaderships = await payload.find({
collection: 'leadership',
where: { id: { in: leadershipIDs } },
depth: 1,
limit: 0,
pagination: false,
select: { contact: true },
overrideAccess: true,
})
const nameByLeadership = new Map<number, string>()
for (const leadership of leaderships.docs) {
const contact = leadership.contact
const name =
typeof contact === 'object' && contact !== null && 'name' in contact
? (contact.name as string)
: 'Contato'
nameByLeadership.set(leadership.id, name)
}
return pledges.docs.map((pledge) => ({
id: pledge.id,
leadershipID: requireRelationshipId(pledge.leadership),
contactName: nameByLeadership.get(requireRelationshipId(pledge.leadership)) ?? 'Contato',
declaredVotes: pledge.declaredVotes,
declaredAt: pledge.declaredAt ?? null,
estimatedVotes: toVoteEstimateScenarioViewModel(pledge.estimatedVotes),
estimateNote: pledge.estimateNote ?? null,
estimatedAt: pledge.estimatedAt ?? null,
}))
}