officeRace.ts

Filename	Percent	Threshold	Total	Covered	Uncovered
src/db/schema/officeRace.ts	100.00%	80%	190	190	0

import { boolean, integer, varchar } from 'drizzle-orm/pg-core';

import { call } from './call.js';
import { candidateAbsenteeEstimate } from './candidateAbsenteeEstimate.js';
import { candidateElectoralVote } from './candidateElectoralVote.js';
import { candidatePriorEstimate } from './candidatePriorEstimate.js';
import { candidateRace } from './candidateRace.js';
import { candidateVote } from './candidateVote.js';
import { delegateAllocation } from './delegateAllocation.js';
import { electionType } from './electionType.js';
import { electoralVote } from './electoralVote.js';
import { jurisdiction } from './jurisdiction.js';
import { jurisdictionRace } from './jurisdictionRace.js';
import { office } from './office.js';
import { officeBody } from './officeBody.js';
import { officeRaceCoveredDistrict } from './officeRaceCoveredDistrict.js';
import { officeVote } from './officeVote.js';
import { relations } from 'drizzle-orm';
import { schema } from './schema.js';
import { state } from './state.js';
import { voteFlag } from './voteFlag.js';

export const officeRace = schema.table('OfficeRace', {
  uid: varchar('uid').primaryKey(),
  candidateListIsFinal: boolean('candidateListIsFinal').notNull(),
  exitPollDescriptionsAreFinal: boolean(
    'exitPollDescriptionsAreFinal'
  ).notNull(),
  totNumCandidates: integer('totNumCandidates').notNull(),
  tabulatedVoteByDistrictIsReported: boolean(
    'tabulatedVoteByDistrictIsReported'
  ).notNull(),
  easEstimatesAreReported: boolean('easEstimatesAreReported').notNull(),
  precinctVoteIsReported: boolean('precinctVoteIsReported').notNull(),
  runoffStatus: varchar('runoffStatus').notNull(),
  tabulatedVoteIsReported: boolean('tabulatedVoteIsReported').notNull(),
  unfusedVoteIsReported: boolean('unfusedVoteIsReported').notNull(),
  exitPollIsReported: boolean('exitPollIsReported').notNull(),
  specialElection: boolean('specialElection').notNull(),

  electionType: varchar('electionType')
    .notNull()
    .references(() => electionType.uid),
  jurisdiction: varchar('jurisdiction')
    .notNull()
    .references(() => jurisdiction.uid),
  jurisdictionRace: varchar('jurisdictionRace')
    .notNull()
    .references(() => jurisdictionRace.uid),
  office: varchar('office')
    .notNull()
    .references(() => office.uid),
  officeBody: varchar('officeBody').references(() => officeBody.uid),
  state: integer('state').references(() => state.uid),
});

export type NewOfficeRace = typeof officeRace.$inferInsert;

export const officeRaceRelations = relations(officeRace, ({ one, many }) => ({
  electionType: one(electionType, {
    fields: [officeRace.electionType],
    references: [electionType.uid],
  }),
  jurisdiction: one(jurisdiction, {
    fields: [officeRace.jurisdiction],
    references: [jurisdiction.uid],
  }),
  jurisdictionRace: one(jurisdictionRace, {
    fields: [officeRace.jurisdictionRace],
    references: [jurisdictionRace.uid],
  }),
  office: one(office, {
    fields: [officeRace.office],
    references: [office.uid],
  }),
  officeBody: one(officeBody, {
    fields: [officeRace.officeBody],
    references: [officeBody.uid],
  }),
  state: one(state, {
    fields: [officeRace.state],
    references: [state.uid],
  }),
  call: one(call),
  candidateAbsenteeEstimates: many(candidateAbsenteeEstimate),
  candidateElectoralVotes: many(candidateElectoralVote),
  candidatePriorEstimates: many(candidatePriorEstimate),
  candidateRaces: many(candidateRace),
  candidateVotes: many(candidateVote),
  voteFlags: many(voteFlag),
  delegateAllocations: many(delegateAllocation),
  electoralVotes: many(electoralVote),
  officeRaceCoveredDistricts: many(officeRaceCoveredDistrict),
  officeVotes: many(officeVote),
}));

[]

TypeScript coverage report