mirror of
https://github.com/fsolla/teqo.git
synced 2026-11-20 01:33:05 +00:00
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.
159 lines
5.2 KiB
TypeScript
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,
|
|
}))
|
|
}
|