index.ts

Filename	Percent	Threshold	Total	Covered	Uncovered
src/results/parsers/national-delegate-summary/index.ts	100.00%	80%	168	168	0

import type { Document } from './types.js';
import type { NewNationalDelegateSummary } from 'db/schema/nationalDelegateSummary.js';
import { parseKey } from 'utils/documentKey.js';
import { prettifyTransmissionSourceTypeCodes } from 'utils/prettifyCodes.js';
import type { NewStateDelegateSummary } from 'db/schema/stateDelegateSummary.js';
import { validateTimestamp } from 'utils/validateTimestamp.js';

/**
 * Parses documents we get from querying the `results/national-delegate-summary` endpoint. It then transforms the data to fit the structure of the NationalDelegateSummary model and returns an array of objects that can be upserted into the model.
 *
 * @NOTE - This data is available only for presidential election years. Edison may have a special eventID for this endpoint.
 *
 * @NOTE - In 2024, Edison provided the wrong values for `delegatesNeededToWin`. Instead of providing 2024 values, they provided 2020 values. Double check the numbers in future elections to ensure they are correct.
 */
const parseNationalDelegateSummary = (documents: Document[]) => {
  const instances: NewNationalDelegateSummary[] = [];

  for (const doc of documents) {
    /**
     * @TODO transSrc is NOT on schema. Is this outdated?
     */
    // @ts-ignore
    const { parties, scp: scope, seq: sequence, ts: timestamp, transSrc } = doc;

    const { electionType, state } = parseKey(doc.key);
    const { eDate, ofc: officeCode } = doc.key;

    // Check that the document contains national data
    const isNational = state === null; // Should always be null for national delegate summary

    if (isNational !== true)
      throw new Error(
        `National delegate should always have national data. isNational is ${isNational} instead`
      );

    // Loop through parties and get delegate vote data
    for (const p of parties) {
      const {
        dNeed: delegatesNeededToWin,
        dVotes: totalDelegatesAllocated,
        pId: party,
      } = p;

      const instance: NewNationalDelegateSummary = {
        uid: party,
        /**
         * @NOTE - We can't make model associations because the event containing the `results/national-delegate-summary` do not provide data for any of the `events/` endpoints. So, set these as regular keys.
         * */
        electionType, //
        party, //

        // Delegate vote data
        delegatesNeededToWin,
        totalDelegatesAllocated,

        // Summary/national flags
        isSummary: scope === 'S',
        isNational, // should always be null for national delegate summary

        // Document metadata
        scope,
        sequence,
        timestamp: validateTimestamp(timestamp),
        transmissionSource: prettifyTransmissionSourceTypeCodes(transSrc),
        electionDate: validateTimestamp(eDate),
        officeCode,
      };
      instances.push(instance);
    }
  }
  return instances;
};

const parseStateDelegateSummary = (documents: Document[]) => {
  const instances: NewStateDelegateSummary[] = [];
  for (const doc of documents) {
    /**
     * @TODO transSrc is NOT on schema. Is this outdated?
     */
    // @ts-ignore
    const { parties, scp: scope, seq: sequence, ts: timestamp, transSrc } = doc;

    /** The document key sets jurisdiction type as NR (national) and does not contain individual state information, so we don't use the `state` value in the key. */
    const { electionType } = parseKey(doc.key);
    const { eDate, ofc: officeCode } = doc.key;

    // Check that the document contains summary data
    const isSummary = scope === 'S'; // should always be true for national delegate summary
    if (isSummary !== true)
      throw new Error(
        `National delegate summary should always contain summary data. isSummary is ${isSummary} instead`
      );

    // Loop through parties
    for (const p of parties) {
      const {
        /** These fields are in the NationalDelegateSummary model, not StateDelegateSummary */
        //   dNeed: delegatesNeededToWin,
        //   dvotes: totalDelegatesAllocated,
        pId: party,
        states,
      } = p;

      // Loop through states
      for (const s of states) {
        const { st, candidates } = s;

        // Loop through candidates
        for (const c of candidates) {
          const {
            cId: candidate,
            dTot: totalDelegates,
            sdTot: totalSuperDelegates,
          } = c;

          const instance: NewStateDelegateSummary = {
            /** Some non-human candidates such as candidate ID 21303 ('Write-ins') are duplicated and both parties may have entries with this candidate ID. So, we have to specify the party in the UID to avoid duplicates. */
            uid: `${candidate}_${party}_${st}`,
            /**
             * @NOTE - We can't make model associations because the event containing the `results/national-delegate-summary` do not provide data for any of the `events/` endpoints. So, set these as regular keys.
             * */
            candidate,
            electionType,
            party,
            state: st, // May contain pseudo states, i.e. Overseas Dems/Reps, DC, Puerto Rico, etc.

            // Should always be P for president
            officeCode,

            // delegate vote data for each candidate
            totalDelegates,
            totalSuperDelegates,

            // Check if it's pseudo state
            pseudoState: st > 51,

            // Summary flag
            isSummary,

            scope,
            sequence,
            timestamp: validateTimestamp(timestamp),
            transmissionSource: prettifyTransmissionSourceTypeCodes(transSrc),
            electionDate: validateTimestamp(eDate),
          };
          instances.push(instance);
        }
      }
    }
  }
  return instances;
};

const parseSequenceId = (doc: Document) => {
  const { electionType, state } = parseKey(doc.key);
  return `${state}_${electionType}`;
};

export default {
  parseSequenceId,
  parseNationalDelegateSummary,
  parseStateDelegateSummary,
};

[]

TypeScript coverage report