index.ts

Filename	Percent	Threshold	Total	Covered	Uncovered
src/events/index.ts	96.93%	80%	586	568	18

import { type DB, Query } from 'db/index.js';
import {
  parseCountyExpectedVoteStrata,
  parseCountyGeoStrata,
  parseCountyPartyStrata,
  parseCountyStrata,
} from './parsers/county-by-elec/countyStrata.js';
import {
  parseDelegateDistrictCounties,
  parseDelegateDistricts,
} from './parsers/delegate-district/delegateDistrict.js';

import { Endpoints } from '../endpoints/index.js';
import type { Logger } from 'winston';
import { absenteeMethod } from 'db/schema/absenteeMethod.js';
import { candidate } from 'db/schema/candidate.js';
import { candidateAbsenteeEstimate } from 'db/schema/candidateAbsenteeEstimate.js';
import { candidatePriorEstimate } from 'db/schema/candidatePriorEstimate.js';
import { candidateRace } from 'db/schema/candidateRace.js';
import { candidateRace_office } from 'db/schema/candidateRace_office.js';
import { candidateRace_party } from 'db/schema/candidateRace_party.js';
import { county } from 'db/schema/county.js';
import { countyByJurisdiction } from 'db/schema/countyByJurisdiction.js';
import { countyDemographic } from 'db/schema/countyDemographic.js';
import { countyExpectedVote } from 'db/schema/countyExpectedVote.js';
import { countyExpectedVoteStratum } from 'db/schema/countyExpectedVoteStratum.js';
import { countyGeoStratum } from 'db/schema/countyGeoStratum.js';
import { countyPartyStratum } from 'db/schema/countyPartyStratum.js';
import { countyRegisteredVotersByParty } from 'db/schema/countyRegisteredVotersByParty.js';
import { delegateDistrict } from 'db/schema/delegateDistrict.js';
import { delegateDistrictCounty } from 'db/schema/delegateDistrictCounty.js';
import { delegateDistrictType } from 'db/schema/delegateDistrictType.js';
import { documentScope } from 'db/schema/documentScope.js';
import documentScopeFixtures from './fixtures/documentScope.js';
import { electionType } from 'db/schema/electionType.js';
import { event } from 'db/schema/event.js';
import { jurisdiction } from 'db/schema/jurisdiction.js';
// import { jurisdictionPastRace } from 'db/schema/jurisdictionPastRace.js';
import { jurisdictionRace } from 'db/schema/jurisdictionRace.js';
import { jurisdictionType } from 'db/schema/jurisdictionType.js';
import { office } from 'db/schema/office.js';
import { officeBody } from 'db/schema/officeBody.js';
import officeBodyFixtures from './fixtures/officeBody.js';
import { officeBody_electionType } from 'db/schema/officeBody_electionType.js';
import { officeRace } from 'db/schema/officeRace.js';
import { officeRaceCoveredDistrict } from 'db/schema/officeRaceCoveredDistrict.js';
import { parseAbsenteeMethods } from './parsers/absentee-method/absenteeMethod.js';
import { parseCandidateAbsenteeEstimates } from './parsers/election-race/candidateAbsenteeEstimate.js';
import { parseCandidatePriorEstimates } from './parsers/election-race/candidatePriorEstimate.js';
import { parseCandidateRaceOffices } from './parsers/election-race/candidateRaceOffice.js';
import { parseCandidateRaceParties } from './parsers/election-race/candidateRaceParty.js';
import { parseCandidateRaces } from './parsers/election-race/candidateRace.js';
import { parseCandidates } from './parsers/election-race/candidate.js';
import { parseCounties } from './parsers/county-by-state/county.js';
import { parseCountiesByJurisdiction } from './parsers/county-by-elec/countyByJurisdiction.js';
import { parseCountiesDemographic } from './parsers/county-by-elec/countyDemographic.js';
import { parseCountyExpectedVotes } from './parsers/county-by-elec/countyExpectedVote.js';
import { parseCountyRegisteredVotersByParties } from './parsers/county-by-state/countyRegisteredVotersByParty.js';
import { parseDelegateDistrictTypes } from './parsers/delegate-district-type/delegateDistrictType.js';
import { parseElectionTypes } from './parsers/election/electionType.js';
// import { parseJurisdictionPastRaces } from './parsers/election/jurisdictionPastRace.js';
import { parseJurisdictionRaces } from './parsers/election/jurisdictionRace.js';
import { parseJurisdictionTypes } from './parsers/election/jurisdictionType.js';
import { parseJurisdictions } from './parsers/election/jurisdiction.js';
import { parseOfficeBodyElectionTypes } from './parsers/election-race/officeBodyElectionType.js';
import { parseOfficeRaceCoveredDistricts } from './parsers/election-race/officeRaceCoveredDistrict.js';
import { parseOfficeRaces } from './parsers/election-race/officeRace.js';
import { parseOffices } from './parsers/election-race/office.js';
import { parseParties } from './parsers/party-lookup/party.js';
import { parsePartiesByOffice } from './parsers/party-by-office/partyByOffice.js';
// import { parsePastCandidateVotes } from './parsers/past-county-data/pastCandidateVote.js';
// import { parsePastCandidateVotesByCounty } from './parsers/past-county-data/pastCandidateVoteByCounty.js';
// import { parsePastCountyVotes } from './parsers/past-county-data/pastCountyVote.js';
import { parseStateElectionTypes } from './parsers/election/stateElectionType.js';
import { parseStateExpectedVotes } from './parsers/county-by-elec/stateExpectedVote.js';
import { parseStates } from './parsers/county-by-state/state.js';
import { party } from 'db/schema/party.js';
import { partyByOffice } from 'db/schema/partyByOffice.js';
// import { pastCandidateVote } from 'db/schema/pastCandidateVote.js';
// import { pastCandidateVoteByCounty } from 'db/schema/pastCandidateVoteByCounty.js';
// import { pastCountyVote } from 'db/schema/pastCountyVote.js';
import { state } from 'db/schema/state.js';
import { stateExpectedVote } from 'db/schema/stateExpectedVote.js';
import { state_electionType } from 'db/schema/state_electionType.js';
import { turnoutStage } from 'db/schema/turnoutStage.js';
import turnoutStageFixtures from '../results/fixtures/turnoutStage.js';

type Config = {
  apiKey: string;
  eventId: string;
  db: DB;
  logger?: Logger;
};

export class Events extends Endpoints {
  query: Query;
  constructor({ logger, apiKey, eventId, db }: Config) {
    super({ logger, apiKey, eventId, db });
    this.query = new Query(db, logger);
  }

  /**
   * Sets up an election event by populating the database with election event metadata such as information about states, races, political parties and candidates.
   */
  async setupEvent() {
    await this.makeOfficeBodies();
    await this.makeDocumentScopes();
    await this.makeTurnoutStages();
    await this.makeAbsenteeMethods();
    await this.makeStatesCountiesJurisdictionsAndElectionTypes();
    await this.makeParties();
    await this.makeOfficesAndCandidates();
    await this.makePartiesByOffice();
    /**
     * @TODO Review
     */
    // await this.makeCountiesPastData();
    await this.makeDistrictTypes();
    await this.makeDistricts();
    await this.makeEvent();
  }

  /**
   * Makes the event in the database confirms the event has been successfully setup for later results methods.
   */
  private async makeEvent() {
    this.logger.info('Making event');
    const eventInstance = { uid: this.eventId, id: this.eventId };
    await this.query.bulkUpsert(event, [eventInstance]);
  }

  private async makeOfficeBodies() {
    this.logger.info('Making office bodies');
    await this.query.bulkUpsert(officeBody, officeBodyFixtures);
  }

  private async makeTurnoutStages() {
    this.logger.info('Making turnout stages');
    await this.query.bulkUpsert(turnoutStage, turnoutStageFixtures);
  }

  private async makeDocumentScopes() {
    this.logger.info('Making document scopes');
    await this.query.bulkUpsert(documentScope, documentScopeFixtures);
  }

  private async makeAbsenteeMethods() {
    this.logger.info('Making absentee methods');
    const documents = await this.getEventsAbsenteeMethod();
    const instances = parseAbsenteeMethods(documents);
    await this.query.bulkUpsert(absenteeMethod, instances);
  }

  private async makeStatesCountiesJurisdictionsAndElectionTypes() {
    this.logger.info(
      'Making states, counties, jurisdictions and election types'
    );
    const eDocuments = await this.getEventsElection();
    const cbsDocuments = await this.getEventsCountyByState();
    const cbeDocuments = await this.getEventsCountyByElec();

    const states = parseStates(cbsDocuments, eDocuments);
    await this.query.bulkUpsert(state, states);

    await this.makeElectionTypes(eDocuments);

    // Make sure to make State_ElectionType after State since State_ElectionType has to associate with the State model
    await this.makeStateElectionTypes(eDocuments);

    const counties = parseCounties(cbsDocuments);
    await this.query.bulkUpsert(county, counties);

    const countyRegisteredVotersByParties =
      parseCountyRegisteredVotersByParties(cbsDocuments);
    await this.query.bulkUpsert(
      countyRegisteredVotersByParty,
      countyRegisteredVotersByParties
    );

    const countiesDemographic = parseCountiesDemographic(cbeDocuments);
    await this.query.bulkUpsert(countyDemographic, countiesDemographic);

    await this.makeCountyStrata(cbeDocuments);
    const countiesWithStrata = parseCountyStrata(cbeDocuments);
    await this.query.bulkUpsert(county, countiesWithStrata);

    await this.makeJurisdictionTypes(eDocuments);
    await this.makeJurisdictions(eDocuments);
    await this.makeCountiesByJurisdiction(cbeDocuments);

    await this.makeStateExpectedVotes(cbeDocuments);
    await this.makeCountyExpectedVotes(cbeDocuments);
  }

  private async makeCountyStrata(documents) {
    this.logger.info('Making county strata');
    const geoStrata = parseCountyGeoStrata(documents);
    const partyStrata = parseCountyPartyStrata(documents);
    const expectedVoteStrata = parseCountyExpectedVoteStrata(documents);

    await this.query.bulkUpsert(countyExpectedVoteStratum, expectedVoteStrata);
    await this.query.bulkUpsert(countyGeoStratum, geoStrata);
    await this.query.bulkUpsert(countyPartyStratum, partyStrata);
  }

  private async makeCountyExpectedVotes(documents) {
    this.logger.info('Making county expected votes');
    const expectedVotes = parseCountyExpectedVotes(documents);
    await this.query.bulkUpsert(countyExpectedVote, expectedVotes);
  }

  private async makeStateExpectedVotes(documents) {
    this.logger.info('Making state expected votes');
    const expectedVotes = parseStateExpectedVotes(documents);
    await this.query.bulkUpsert(stateExpectedVote, expectedVotes);
  }

  private async makeElectionTypes(documents) {
    this.logger.info('Making election types');
    const electionTypes = parseElectionTypes(documents);
    await this.query.bulkUpsert(electionType, electionTypes);
  }

  private async makeStateElectionTypes(documents) {
    this.logger.info('Making state election types');
    const stateElectionTypes = parseStateElectionTypes(documents);
    await this.query.bulkUpsert(state_electionType, stateElectionTypes);
  }

  private async makeJurisdictionTypes(documents) {
    this.logger.info('Making jurisdiction types');
    const jurisdictionTypes = parseJurisdictionTypes(documents);
    await this.query.bulkUpsert(jurisdictionType, jurisdictionTypes);
  }

  private async makeJurisdictions(documents) {
    this.logger.info('Making jurisdictions and jurisdiction races');

    const jurisdictions = parseJurisdictions(documents);
    const jurisdictionRaces = parseJurisdictionRaces(documents);
    // const pastRaces = parseJurisdictionPastRaces(documents);

    await this.query.bulkUpsert(jurisdiction, jurisdictions);
    await this.query.bulkUpsert(jurisdictionRace, jurisdictionRaces);
    // await this.query.bulkUpsert(jurisdictionPastRace, pastRaces);
  }

  private async makeCountiesByJurisdiction(documents) {
    this.logger.info('Making counties by jurisdiction');
    const counties = parseCountiesByJurisdiction(documents);
    await this.query.bulkUpsert(countyByJurisdiction, counties);
  }

  private async makeParties() {
    this.logger.info('Making parties');
    const documents = await this.getEventsPartyLookup();
    const parties = parseParties(documents);
    await this.query.bulkUpsert(party, parties);
  }

  private async makeOfficesAndCandidates() {
    const documents = await this.getEventsElectionRace();
    await this.makeOffices(documents);
    await this.makeCandidates(documents);
  }

  private async makeOffices(documents) {
    this.logger.info('Making offices');
    const offices = parseOffices(documents);
    const officeRaces = parseOfficeRaces(documents);
    const districtCovered = parseOfficeRaceCoveredDistricts(documents);
    const officeBodyElectionTypes = parseOfficeBodyElectionTypes(documents);

    // We need to upsert to the OfficeBody_ElectionType model before we upsert to other models such as OfficeRace
    await this.query.bulkUpsert(
      officeBody_electionType,
      officeBodyElectionTypes
    );
    await this.query.bulkUpsert(office, offices);
    await this.query.bulkUpsert(officeRace, officeRaces);
    await this.query.bulkUpsert(officeRaceCoveredDistrict, districtCovered);
  }

  private async makeCandidates(documents) {
    this.logger.info('Making candidates');
    const candidates = parseCandidates(documents);
    const candidateRaces = parseCandidateRaces(documents);

    await this.query.bulkUpsert(candidate, candidates);
    await this.query.bulkUpsert(candidateRace, candidateRaces);

    await this.makeCandidateRaceOffices(documents);
    await this.makeCandidateParties(documents);
    await this.makeCandidateAbsenteeEstimates(documents);
    await this.makeCandidatePriorEstimates(documents);
  }

  private async makeCandidateRaceOffices(documents) {
    this.logger.info('Making candidate offices');
    const candidateRaceOffices = parseCandidateRaceOffices(documents);

    await this.query.bulkUpsert(candidateRace_office, candidateRaceOffices);
  }

  private async makeCandidateParties(documents) {
    this.logger.info('Making candidate parties');
    const candidateParties = parseCandidateRaceParties(documents);

    await this.query.bulkUpsert(candidateRace_party, candidateParties);
  }

  private async makeCandidateAbsenteeEstimates(documents) {
    this.logger.info('Making candidate absentee estimates');
    const estimates = parseCandidateAbsenteeEstimates(documents);
    await this.query.bulkUpsert(candidateAbsenteeEstimate, estimates);
  }

  private async makeCandidatePriorEstimates(documents) {
    this.logger.info('Making candidate prior estimates');
    const estimates = parseCandidatePriorEstimates(documents);
    await this.query.bulkUpsert(candidatePriorEstimate, estimates);
  }

  private async makePartiesByOffice() {
    this.logger.info('Making parties by office');
    const documents = await this.getEventsPartyByOffice();
    const partiesByOffice = parsePartiesByOffice(documents);
    await this.query.bulkUpsert(partyByOffice, partiesByOffice);
  }

  private async makeDistrictTypes() {
    this.logger.info('Making delegate district types');
    const documents = await this.getEventsDelegateDistrictType();
    const districtTypes = parseDelegateDistrictTypes(documents);
    await this.query.bulkUpsert(delegateDistrictType, districtTypes);
  }

  private async makeDistricts() {
    this.logger.info('Making delegate districts');
    const documents = await this.getEventsDelegateDistrict();
    const delegateDistricts = parseDelegateDistricts(documents);
    const delegateDistrictCounties = parseDelegateDistrictCounties(documents);

    await this.query.bulkUpsert(delegateDistrict, delegateDistricts);
    await this.query.bulkUpsert(
      delegateDistrictCounty,
      delegateDistrictCounties
    );
  }

  /** @TODO REVIEW */
  // async makeCountiesPastData() {
  //   this.logger.info('Making counties past data');

  //   const pastCountyDatadocuments = await this.getEventsPastCountyData();
  //   const countyVotes = parsePastCountyVotes(pastCountyDatadocuments);
  //   const candidateVotes = parsePastCandidateVotes(pastCountyDatadocuments);
  //   const candidateVotesByCounty = parsePastCandidateVotesByCounty(
  //     pastCountyDatadocuments
  //   );

  //   /**
  //    * @TODO - Discuss with Jon
  //    * We can use the filtering code below to filter out candidates who are no longer running. Filtering would allow us to associate PastCandidateVote to the Candidate model.
  //    *
  //    * For now, I'm keeping all the past candidate votes data and dropping the Candidate model association.
  //    * */
  //   // pastCountyDatadocuments includes data for candidates who are no longer running and
  //   // whose metadata are not included in other events endpoint documents such as
  //   // `election-race`, which contains candidate metadata.
  //   // So we need to filter out those candidates who are no longer relevant,
  //   // i.e. whose metadata we do not have.

  //   // // Get a list of candidates running in this election year
  //   //    const electionRaceDocuments = await this.getEventsElectionRace();
  //   //    const candidates = parseCandidates(electionRaceDocuments);

  //   // // Filter candidateVotes to only include candidates running in this election year
  //   // const filteredCandidateVotes = candidateVotes.filter(candidateVote => {
  //   //   const { candidate } = candidateVote;

  //   //   // Check if candidate is in candidates metadata array
  //   //   const candidateMetadataExists = candidates.find(doc => doc.uid === candidate);
  //   //   return !!candidateMetadataExists;
  //   // });

  //   // // Get the number of candidates who were filtered out
  //   // const numCandidatesFilteredOut = candidateVotes.length - filteredCandidateVotes.length;

  //   // this.logger.info(`Filtered out ${numCandidatesFilteredOut} candidates from past-county-data document.`);

  //   // If we want to use filteredCandidateVotes instead
  //   // await this.db.bulkUpsert(this.db.models.PastCandidateVote, filteredCandidateVotes);
  //   await this.query.bulkUpsert(pastCandidateVote, candidateVotes);
  //   await this.query.bulkUpsert(
  //     pastCandidateVoteByCounty,
  //     candidateVotesByCounty
  //   );
  //   await this.query.bulkUpsert(pastCountyVote, countyVotes);
  // }
}

[{"file":"src/events/index.ts","line":194,"character":33,"text":"documents","kind":1},{"file":"src/events/index.ts","line":205,"character":40,"text":"documents","kind":1},{"file":"src/events/index.ts","line":211,"character":39,"text":"documents","kind":1},{"file":"src/events/index.ts","line":217,"character":34,"text":"documents","kind":1},{"file":"src/events/index.ts","line":223,"character":39,"text":"documents","kind":1},{"file":"src/events/index.ts","line":229,"character":38,"text":"documents","kind":1},{"file":"src/events/index.ts","line":235,"character":34,"text":"documents","kind":1},{"file":"src/events/index.ts","line":247,"character":43,"text":"documents","kind":1},{"file":"src/events/index.ts","line":266,"character":28,"text":"documents","kind":1},{"file":"src/events/index.ts","line":283,"character":31,"text":"documents","kind":1},{"file":"src/events/index.ts","line":291,"character":40,"text":"documents","kind":1},{"file":"src/events/index.ts","line":292,"character":36,"text":"documents","kind":1},{"file":"src/events/index.ts","line":293,"character":46,"text":"documents","kind":1},{"file":"src/events/index.ts","line":294,"character":43,"text":"documents","kind":1},{"file":"src/events/index.ts","line":297,"character":41,"text":"documents","kind":1},{"file":"src/events/index.ts","line":304,"character":37,"text":"documents","kind":1},{"file":"src/events/index.ts","line":311,"character":47,"text":"documents","kind":1},{"file":"src/events/index.ts","line":317,"character":44,"text":"documents","kind":1}]

TypeScript coverage report